Back to Articles
AI Agents & Architecture
•11 min read•Zero-Infrastructure Agent Guide

Send a Signing Packet from an AI Agent Without Standing Up Webhooks: Direct API & MCP Polling Guide (2026)

How autonomous AI agents in Claude Code, Google Antigravity, Cursor, and serverless runtimes dispatch legally binding PDF and Markdown signing packets via POST /api/v1/send or npx -y signbee-mcp and verify completion via GET /api/v1/documents/{id}—with zero webhook receivers or ngrok tunnels.

Quick Answer (TL;DR)

NAT-Friendly Agent Signing • Single-Call Dispatch • Deterministic Status Polling

Autonomous agents running on developer laptops, CI containers, or ephemeral sandboxes cannot receive inbound HTTP webhooks without opening firewall ports. Signbee eliminates this bottleneck: install npx -y signbee-mcp (or npx skills add signbee/skill) to dispatch contracts via send_document / send_document_pdf (POST https://signb.ee/api/v1/send), returning status: "pending_recipient". Your agent then checks GET https://signb.ee/api/v1/documents/{id} on demand until status === "signed" and retrieves the SHA-256 sealed signed_pdf_url.

Zero Inbound Ports Required
Markdown or PDF URL Input
Instant SHA-256 Sealed PDF URL

1. Why Inbound Webhooks Are an Anti-Pattern for Local & Ephemeral AI Agents

Legacy e-signature platforms were architected in 2012 for monolithic web servers with static public IP addresses. When an engineer using Claude Code, Google Antigravity, Cursor, or an ephemeral E2B/Modal sandbox wants an agent to send an NDA and wait for signature completion before provisioning credentials, setting up a public webhook listener is a major operational hurdle.

While Signbee supports HMAC-SHA256 webhooks for persistent backend services (see our Webhook Idempotency & HMAC Architecture Guide), autonomous agents thrive on outbound-only HTTP primitives: a single atomic POST /api/v1/send call followed by stateless GET /api/v1/documents/{id} polling.

2. Architecture Comparison: Webhook-Heavy Envelopes vs. Direct Agent Polling

Workflow DimensionSignbee Direct API & MCP PollingLegacy Envelope + Webhook Listener
Agent Setup Commandnpx -y signbee-mcp / npx skills add signbee/skillngrok + Express server + OAuth 2.0 callback
Dispatch Call (Markdown or PDF)POST /api/v1/send (send_document / send_document_pdf)3–5 multipart API calls + X/Y anchor coordinates
Sender (Party A) VerificationImmediate via Bearer API Key (status: pending_recipient)Requires separate sender email confirmation loop
Completion CheckGET /api/v1/documents/{id} (Outbound HTTPS only)Public inbound webhook receiver required

3. Step 1: Equip Your Agent with Signbee MCP or the Declarative Skill

Whether your agent runs in Claude Code, Google Antigravity, Cursor, or a custom TypeScript/Python worker, you can give it instant access to send_document (Markdown) and send_document_pdf (PDF URL) in one command:

Terminal — Install Signbee Skill & MCP ServerShell
# Install the declarative SKILL.md for zero-hallucination API calls
npx skills add signbee/skill --skill signbee -g

# Or run the stdio MCP server (exposes send_document and send_document_pdf)
SIGNBEE_API_KEY="signbee_live_your_key" npx -y signbee-mcp

4. Step 2: Single-Call Dispatch & Webhook-Free Polling in TypeScript

When calling POST https://signb.ee/api/v1/send with an Authorization: Bearer signbee_live_... header, Signbee automatically authenticates you as Party A (the sender), skips sender confirmation emails, sets status: "pending_recipient", and emails the signing link to Party B. Your agent can then poll GET https://signb.ee/api/v1/documents/{id} until completion:

agent-dispatch-and-poll.tsTypeScript / Node.js 22
export interface SignbeeDocumentStatus {
  document_id: string;
  status: "pending_sender" | "pending_recipient" | "signed" | "expired";
  title: string;
  sender: string;
  recipient: { name: string; email: string };
  signed_at: string | null;
  expires_at: string;
  signed_pdf_url: string | null;
}

export async function dispatchAndPollSigningPacket(params: {
  title: string;
  markdown?: string;
  pdf_url?: string;
  recipient_name: string;
  recipient_email: string;
}): Promise<SignbeeDocumentStatus> {
  const apiKey = process.env.SIGNBEE_API_KEY;
  if (!apiKey) throw new Error("Missing SIGNBEE_API_KEY");

  // 1. Dispatch via POST /api/v1/send (supports either markdown or pdf_url)
  const sendRes = await fetch("https://signb.ee/api/v1/send", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${apiKey}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      title: params.title,
      ...(params.markdown ? { markdown: params.markdown } : { pdf_url: params.pdf_url }),
      recipient_name: params.recipient_name,
      recipient_email: params.recipient_email,
      expires_in_days: 7,
    }),
  });

  if (!sendRes.ok) {
    throw new Error(`Dispatch failed (${sendRes.status}): ${await sendRes.text()}`);
  }

  const { document_id } = (await sendRes.json()) as {
    document_id: string;
    status: "pending_recipient";
  };

  // 2. Poll GET /api/v1/documents/{id} without any inbound webhook server
  const statusUrl = `https://signb.ee/api/v1/documents/${document_id}`;
  for (let attempt = 1; attempt <= 60; attempt++) {
    const pollRes = await fetch(statusUrl, {
      headers: { "Authorization": `Bearer ${apiKey}` },
    });
    if (!pollRes.ok) {
      throw new Error(`Status check failed (${pollRes.status})`);
    }

    const doc = (await pollRes.json()) as SignbeeDocumentStatus;
    if (doc.status === "signed" && doc.signed_pdf_url) {
      return doc; // Contains signed_pdf_url with two-pass SHA-256 certificate
    }
    if (doc.status === "expired") {
      throw new Error(`Document ${document_id} expired before signature.`);
    }

    await new Promise((resolve) => setTimeout(resolve, 10_000));
  }

  throw new Error(`Polling window elapsed for document ${document_id}`);
}

5. Cryptographic Audit Trail on the Sealed PDF

As soon as GET /api/v1/documents/{id} returns status: "signed", the returned signed_pdf_url points to a two-pass SHA-256 sealed PDF generated by pdf-lib. You can learn more about our cryptographic verification pipeline in our Claude Skills + Signbee MCP guide and Google Antigravity & Gemini CLI MCP guide.

6. Frequently Asked Questions: Webhook-Free Agent Signing

Why can't local AI agents in Claude Code, Cursor, or Google Antigravity receive traditional e-signature webhooks?

Desktop IDE agents, terminal CLI sessions, and ephemeral cloud sandboxes run behind NAT firewalls without static public IP addresses or open inbound HTTPS ports. Requiring an ngrok tunnel or dedicated Express webhook server just to check if a contract was signed breaks zero-config agent autonomy.

How does an AI agent dispatch a signing packet in a single call with Signbee?

The agent either invokes the MCP tools send_document (for Markdown) or send_document_pdf (for PDF URLs) via npx -y signbee-mcp, or sends an authenticated POST request to https://signb.ee/api/v1/send with title, markdown (or pdf_url), recipient_name, and recipient_email.

How does an AI agent check whether a recipient has signed without standing up a webhook receiver?

The agent queries GET https://signb.ee/api/v1/documents/{id} with its Authorization: Bearer signbee_live_... header. The endpoint returns the current lifecycle status (pending_recipient, signed, or expired) along with signed_pdf_url once completed.

Is the PDF returned by GET /api/v1/documents/{id} cryptographically sealed?

Yes. As soon as Party B signs, Signbee executes a two-pass pdf-lib cryptographic seal that appends a dedicated Signing Certificate page (binding both parties' timestamps, IP addresses, and signatures) and computes the SHA-256 hash of the final PDF byte stream.

Send Signing Packets from Any Agent in One HTTP Call

No webhooks, no ngrok tunnels, no X/Y coordinates. Run npx -y signbee-mcp or call POST /api/v1/send free for up to 5 documents/month.