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.

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.

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.

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.

OpenAPI spec Plans with API access

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.

Read envelope and recipient status

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

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
OAuth, user-scoped tokens or per-key scopes

Quickstart

Five minutes, start to first webhook.

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 · Check you can reach the API

No key needed for this one.
```
curl https://api.accordsign.app/v1/health
{"status":"ok"}
```
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 · 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 · 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.viewed → envelope.signed → envelope.completed arrive.

Webhooks

Events and verification.

Event	Fires when	Recipient
envelope.sent	An envelope created through the API was dispatched. Envelopes sent from the Accordsign app do not emit this event yet.	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.

Matching on error codes

One wrinkle worth knowing while it lasts. Errors are shaped { "error": { "code": "...", "message": "..." } }, but 401, 403 and 429 currently serialise those two keys capitalised (Code, Message) while other statuses use lowercase. Match the key case-insensitively and you will be right either way. We are fixing it.

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.
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.

Read the OpenAPI spec Talk to us