Accordsign

Developers

Send and track signing from your own systems.

A REST API that creates and sends envelopes, tracks them, voids them and hands back the sealed PDF — with HMAC-signed webhooks so your CRM, ERP or internal tooling knows the moment a document is viewed, signed or completed, without anyone checking a dashboard.

API contract 1.11.0

Scope

What it does.

Enough to run signing end to end from your own systems: create the envelope, place the fields, send it, watch it, and collect the finished document. The one thing worth planning around is that there is no sandbox — every key is a live key.

Create and send an envelope

From one of your templates, filling each role with a real recipient — or ad hoc from a document you upload. Both modes place the fields in the request itself.

Place fields by coordinate

x and y as a percentage of the page, width and height in pixels against the dimensions the documents endpoint reports. Every signer needs at least one field.

Create a draft that is never sent

From text, or a PDF or DOCX — up to 2 MB inline in the request, or larger if you upload it first. Nothing is sent, no fields are placed and no document allowance is used — a person opens it in Accordsign, places the fields and sends it. A draft that times out while its document is prepared resumes when you retry with the same Idempotency-Key.

Upload a document

A PDF or DOCX up to 20 MB. Processing is asynchronous: poll until the document is ready, then send it or create a draft from it. Each upload is used once.

Discard a draft

Deletes a draft created through the API, with its document. Nothing is sent. Drafts made in the app and envelopes already sent cannot be discarded — void a sent one instead.

Read envelope and recipient status

List envelopes with cursor pagination and filters, or fetch one envelope with per-recipient state, roles, sequence and timestamps, including when it completed.

Count envelopes by status

One call returns a total and a count for every status across the whole account, zeros included, so you never page the full list just to count it.

Void an envelope

Cancel before completion. Anyone who still owed an action is emailed, and signatures already collected are kept as a record.

Pull the certificate and the sealed PDF

The ordered audit trail for a completed envelope, and the final sealed document once it exists. Aadhaar envelopes carry the eSign provider's seal rather than ours.

Receive signed webhooks

HMAC-signed events pushed to your endpoint on all seven envelope events, with endpoint management and secret rotation through the API.

Not available through the API

Stated openly so you can plan around it rather than discover it mid-build.

  • A sandbox or test mode. Keys are live keys.
  • Creating or editing templates
  • Bulk Send
  • SDKs, client libraries or a Postman collection — the MCP connector below is an agent tool, not a client library
  • OAuth, user-scoped tokens or per-key scopes
  • Aadhaar eSign is not available through the Public API or the MCP connector. Aadhaar envelopes are sent from the web app or the Salesforce package.
  • Drafts from a template are not available through the Public API. Sending from a template is; a draft starts from text, or a PDF or DOCX.

Quickstart

Five minutes, start to first webhook.

  1. 1 · Create a key

    In the Accordsign app go to Account → API keys and create one. Only the account owner can do this. The key is shown once and stored as a hash, so copy it then — it cannot be recovered. Up to five live keys per account, and revoking one takes effect immediately.

  2. 2 · Check you can reach the API

    No key needed for this one.

    curl https://api.accordsign.app/v1/health
    {"status":"ok"}
  3. 3 · List your envelopes

    Authenticate with a bearer token. Watch the X-RateLimit-* headers on the response — they are on every response, not just refusals.

    curl "https://api.accordsign.app/v1/envelopes?limit=5" \
      -H "Authorization: Bearer as_live_YOUR_KEY"

    Returns { data: [...], next_cursor, has_more }. Filter with status, from_date and to_date; page with cursor. limit accepts 1–100 and defaults to 25.

  4. 4 · Read one envelope

    curl https://api.accordsign.app/v1/envelopes/ENVELOPE_ID \
      -H "Authorization: Bearer as_live_YOUR_KEY"

    You get the envelope plus a recipients[] array with each person's role, status, sequence and last event. An envelope belonging to another account returns 404 rather than 403, so ids cannot be probed.

  5. 5 · Register a webhook and watch it fire

    Register one HTTPS endpoint per account, either from the app or with POST /v1/webhooks. Store the whsec_ secret it returns — it is shown at registration and at rotation, and never again. Then send a document from the web app and watch envelope.sent → envelope.viewed → envelope.signed → envelope.completed arrive.

Webhooks

Events and verification.

Event Fires when Recipient
envelope.sent An envelope was dispatched and its signing requests went out — whether sent through the API, from the app, or as one envelope of a Bulk Send. Envelopes sent through the Salesforce package do not emit this event. no
envelope.viewed A recipient opens the signing link for the first time. Once per recipient. yes
envelope.signed A recipient completes their part. Once per recipient. yes
envelope.declined A recipient declines. yes
envelope.voided The sender revoked the envelope before it completed. Terminal. no
envelope.completed The last required signature landed and the final document exists. no
envelope.expired The envelope passed its expiry without completing. no

Verifying the signature

Every delivery carries X-AccordSign-Signature: t=<unix>,v1=<hex>. The signature is HMAC-SHA256 of "{t}.{raw body}", keyed with your endpoint secret, lowercase hex. Verify against the raw bytes — re-serialising the JSON changes them. Timestamps outside a five-minute tolerance are rejected in both directions.

import hashlib, hmac, time

def verify(raw_body: bytes, header: str, secret: str) -> bool:
    parts = dict(p.split("=", 1) for p in header.split(","))
    if abs(int(time.time()) - int(parts["t"])) > 300:
        return False
    expected = hmac.new(
        secret.encode(),
        f'{parts["t"]}.'.encode() + raw_body,
        hashlib.sha256,
    ).hexdigest()
    return hmac.compare_digest(expected, parts["v1"])

Delivery, retries and disablement

Return any 2xx within ten seconds once you have durably accepted the event. Anything else counts as a failed attempt. We retry ten times on a fixed schedule — immediately, then +1m, +5m, +15m, +30m, +1h, +2h, +4h, +8h, +8h — about 24 hours end to end. Returning 410 Gone stops retries for that delivery at once. When the budget is exhausted the endpoint is disabled and the account owner is emailed; re-enabling does not replay missed events, so reconcile with the envelopes list.

Delivery is at-least-once and order is not guaranteed. De-duplicate on the event id, which is stable for a given transition. Endpoints must be absolute HTTPS URLs resolving to a public address.

Rate limits

A hard limit per minute, per key.

  • Growth: 60 requests per minute. Enterprise: 180. Counted per API key.
  • The window is a fixed clock minute in UTC — the counter resets at the top of each minute. It is not a sliding window or a token bucket.
  • X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset (seconds until reset) appear on every response.
  • Over the limit you get 429 with Retry-After. It is a hard block, not a throttle: nothing is queued or slowed, and every request is refused until the minute rolls over.
  • A send consumes one document from the key owner's allowance, the same as sending from the app. A send that fails before dispatch is refunded automatically. Reads and webhook deliveries consume no document quota.

AI agents

Connect an AI agent.

Accordsign does not include an AI. Connect the one you already use. The Model Context Protocol (MCP) connector is a small local server that lets Claude Desktop, Claude Code, Cursor or any MCP client that runs local stdio servers read your envelopes and create drafts, using your own API key.

Install

dotnet tool install --global accordsign-mcp
View on NuGet

You will need

  • The .NET 8 SDK
  • An Accordsign API key, created by the account owner
  • A Growth or Enterprise plan

Configure Claude Desktop

Add this to claude_desktop_config.json, replacing the path with your own home folder and the placeholder with your key. On Windows the command is %USERPROFILE%\.dotnet\tools\accordsign-mcp.exe.

{
  "mcpServers": {
    "accordsign": {
      "command": "/Users/YOUR_NAME/.dotnet/tools/accordsign-mcp",
      "env": {
        "ACCORDSIGN_API_KEY": "as_live_your_key_here",
        "ACCORDSIGN_API_BASE": "https://api.accordsign.app/v1"
      }
    }
  }
}
ACCORDSIGN_API_KEY
Required. Your API key.
ACCORDSIGN_API_BASE
Optional. Defaults to production; leave it unset unless you have been told otherwise.

The seven tools

Tool What it does Writes?
list_envelopes Lists envelopes, newest first, filterable by status. No
get_envelope One envelope in full: status, each recipient's state, timestamps. No
summary_envelopes Counts every envelope on the account by status, in one call. No
list_templates Lists your reusable templates and the roles each one expects. No
get_document Saves the sealed PDF of a completed envelope to a path on your computer. No
create_draft Creates a draft from text, or from a PDF or Word file up to 20 MB. Sends nothing and places no fields. Yes
discard_draft Discards a draft this connector created. Nothing else. Yes

Limits

  • Cannot send or void
  • Discards only drafts it created
  • Document fetch is for completed envelopes only
  • Drafts still need a person to place fields and send

Setup notes

  • Point your client at the absolute path ~/.dotnet/tools/accordsign-mcp, or add that folder to your PATH. MCP clients launch the server themselves and do not always inherit your shell's PATH.
  • After editing the Claude Desktop config, quit Claude Desktop completely and relaunch it. Closing the window is not enough.
  • Update to the latest release with dotnet tool update --global accordsign-mcp.
  • The connector runs on your own computer. It is not available in the Claude web or mobile apps, and it cannot read files you attach to a chat.
Envelope details the connector reads are passed to your AI client and its provider under that provider's terms. Documents it fetches are saved to your computer rather than returned to the AI client directly. Accordsign does not see or process your documents with any AI.
Available on Growth and Enterprise plans, with a key created by the account owner.

Common questions.

Can I send an envelope through the API?
Yes. POST /v1/envelopes creates and sends one, either from a template — filling each role with a real recipient — or ad hoc from a document you upload first. Both modes place the fields in the request, positioned as a percentage of the page, and every signer needs at least one field or the request is refused. Send an Idempotency-Key header and retries are safe: a replay returns the original envelope rather than sending a second one.
Which plans include API access?
Growth and Enterprise. A key created on an eligible plan will start returning 403 on every call if the account is later downgraded to Starter, Individual or a trial.
Is there a sandbox?
No. There is no self-serve sandbox and no test mode. Keys are live keys, and a send through one is a real envelope emailed to a real recipient. Test against an address you control.
Do API calls use up my document allowance?
Sending does. Each send through the API consumes one document from the key owner's allowance, exactly as sending from the app does, and a send that fails before dispatch is refunded automatically. Reads, webhook deliveries and certificate or document downloads consume nothing. The other limit that applies is the per-minute request rate for your plan.
Can I connect an AI agent instead of writing code?
Yes, through the MCP connector described above. Accordsign does not include an AI. Connect the one you already use. The connector can read envelopes, create drafts and discard the drafts it created, but cannot send or void anything. The main FAQ covers what an agent can and cannot do with your account. Read the AI agent questions in the FAQ
What happens if my webhook endpoint is down?
We retry ten times over roughly 24 hours on a fixed schedule. If all attempts fail the delivery is abandoned, your endpoint is disabled and the account owner is emailed. Re-enabling does not replay the missed events — reconcile with a call to the envelopes list.

Start with the spec.

The OpenAPI document is public and authoritative — no key required to read it. API access is available on Growth and Enterprise plans.