ELECTRONIC SIGNATURE API

Electronic signature API.

Add legally binding e-signatures to your SaaS app or product with a clean REST API. Send documents, embed white-label signing, and get notified by webhook the moment a contract is signed. From $0.40 per envelope, with a free sandbox to build against.

REST
Plain JSON
Webhooks
Signed events
Embedded
White-label
Sandbox
Free to build
Electronic signature API request: a POST to /v1/documents sends a contract to a signer, the API responds that it was sent, and a document.completed webhook fires
5,000+
businesses signing since 2021
20+
countries signing worldwide
Audit trail
on every signed document
HOW IT WORKS

How the electronic signature API works.

The electronic signature API works over plain REST. Your app authenticates with an API key, creates a document with its files and recipients, and sends it for signature in code, then gets the sealed PDF and a completion webhook back.

Embedded requesting

Embed the prepare-and-send flow inside your app. Your own users add recipients and fields and send a document for signature without leaving your product.

Templates and fields

Send from reusable templates with fields already placed, or position signature, date, and form fields by coordinates at send time. Same result every time.

Prefill and roles

Pass signer names, emails, and field values in the request so recipients open a document that is already filled in and just needs a signature.

Embedded signing

Open a signing session in an iframe or a redirect so recipients sign inside your app. No hand-off to a separate website, and status is returned by webhook.

Signer authentication

Add an identity check before signing - an email one-time passcode or an access code you share out of band - so only the intended recipient can open and sign.

Customized branding

Put your logo, colors, and domain on the signing pages and the notification emails. Recipients see your brand from the request through to the signed copy, with no third-party footer.

White-label domain

Host the signing page on your own domain with your logo and colors. No third-party branding and no Powered by footer anywhere the signer looks.

Webhooks

Register an endpoint and receive a signed event whenever a document is viewed, signed, completed, or declined. Your backend reacts in real time, with no polling.

New to signing in general? Start with what an electronic signature is and how it is kept legally binding.

QUICKSTART

Add e-signatures to your app in minutes.

Upload a file, add signers, and set send to true. The response returns a document id you can track, and the sealed PDF and audit certificate come back once everyone has signed. Call it with curl or an official SDK - it is plain JSON over HTTPS, so it fits any stack.

SDKsNode.jsPythonPHPRubyGoJavacURL
create and send
curl https://api.documentesign.com/v1/documents \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "title": "NDA - Q3",
    "files": ["file_9f2c"],
    "recipients": [
      { "email": "sam@acme.com",
        "name": "Sam Rivera",
        "role": "signer" }
    ],
    "send": true
  }'
core endpoints
  • POST
    /v1/documentsCreate and optionally send a document
  • PUT
    /v1/documents/:id/recipientsSet signers and signing order
  • PUT
    /v1/documents/:id/fieldsPlace signature and form fields
  • POST
    /v1/documents/:id/sendSend for signature
  • GET
    /v1/documents/:idCheck status and recipients
  • GET
    /v1/documents/:id/files/signedDownload the sealed PDF
  • POST
    /v1/templates/:id/sendSend from a reusable template

Endpoints shown are representative of the REST reference. Approved accounts get the full docs, SDKs, and sandbox keys.

WEBHOOKS

Real-time status, no polling.

Register one endpoint and the API sends a signed event every time a document moves. Your backend updates its own records, advances the workflow, or triggers the next step the moment a contract is signed. Each webhook is signed so you can verify it, and delivery retries if your server is briefly unreachable.

document.sent

Sent to the first recipient

recipient.viewed

A signer opened the document

recipient.signed

A signer finished their fields

document.completed

All recipients signed

document.declined

A signer declined to sign

document.expired

The signing window closed

POST to your endpoint
{
  "event": "document.completed",
  "document": {
    "id": "doc_1a2b3c",
    "status": "completed",
    "signed_pdf": "https://.../signed.pdf",
    "certificate": "https://.../audit.pdf"
  },
  "occurred_at": "2026-07-04T10:41:00Z"
}
DASHBOARD

Track every envelope from one dashboard.

The API dashboard shows exactly what your integration is doing: envelopes sent this month against your plan, delivery and completion rates, your test and live keys, and a running log of recent webhook events. You can watch usage, rotate a key, or replay a failed webhook without leaving the page or opening a ticket.

  • Usage against your plan

    Watch envelopes sent this month against your monthly quota, with delivery and completion rates, so billing never surprises you.

  • Key management

    Create, rotate, and revoke test and live API keys yourself. Separate sandbox and live keys keep your prototype away from real sends.

  • Live event log

    See every webhook the API sent, inspect the payload, and replay a delivery that failed - without touching your own logs.

SECURITY & COMPLIANCE

Legally binding, with a verifiable trail.

Signatures collected through the API are binding under the U.S. ESIGN Act and UETA and under the EU eIDAS regulation. Every completed document is sealed, timestamped, and returned with a full audit record, so the evidence you get in code is the same as everywhere else in the product.

ESIGN ActUETAeIDASAES-256TLS 1.3PAdES-B-LTSHA-256
Encryption
  • AES-256-GCM at rest
  • TLS 1.3 in transit
  • API keys scoped per environment
  • Test and live kept separate
Signature integrity
  • SHA-256 document hash
  • PAdES-B-LT signature embedded
  • Independent TSA timestamp
  • Verifiable in Adobe Acrobat
Evidence
  • Certificate of completion
  • Email, IP, and timestamp per signer
  • Append-only audit log
  • Returned with every document
API PRICING

$0.40/ envelope

Flat pricing, billed by usage. $20 a month includes 40 envelopes, and every account starts with a free sandbox to build and test.

  • $0.40 per envelope, one flat rate
  • $20 a month includes 40 envelopes
  • No per-seat fees, no setup fees
  • Free sandbox to build and test
  • Embedded and white-label signing
  • Webhooks and the full REST reference
Request free sandbox access

Get test and live keys and the full API reference.

FAQ

Electronic signature API - FAQ

What is an electronic signature API?

An electronic signature API is a set of REST endpoints that let your own application send documents for signature, collect legally binding signatures, and track their status, all in code and without anyone logging into a signing product. Instead of a person uploading a PDF and clicking Send, your backend calls an endpoint like POST /v1/documents, adds the signers, and the API handles delivery, reminders, signing, sealing, and the audit trail. You get the signed PDF and a certificate of completion back through a webhook. It is how software products embed signing directly into their own onboarding, contract, or checkout flows.

How do I get an API key?

Request a free sandbox account. The Document eSign API is rolling out to customers now, and access is granted per account rather than through open self-serve signup at this stage. We provision a workspace, issue you a test and a live API key, and share the full endpoint reference so your team can start integrating against the sandbox the same day. There is no charge to build and test in the sandbox, and you only pay once you send live envelopes.

Does the API support embedded signing?

Yes. You can generate a signing URL for any recipient and either redirect the signer to it or drop it into an iframe inside your own app, so the person never leaves your product to sign. The signing page can be fully white-labeled to your brand and hosted on your own domain, which means no third-party logo, no Powered by footer, and a signing experience that looks like a native part of your software rather than a bolt-on.

Can I get notified when a document is signed?

Yes, through webhooks. You register an endpoint on your server and the API sends a signed event payload every time something meaningful happens, such as a recipient viewing a document, a recipient signing, a document completing, or a signer declining. Each webhook is signed so you can verify it came from us, and delivery retries on failure. This is what lets you update your own database, advance a workflow, or trigger the next step the moment a contract is signed, without polling for status.

How much does the electronic signature API cost?

The API is $0.40 USD per envelope, where an envelope is one document package sent for signature regardless of how many signers or pages it contains. Plans start at $20 a month with 40 envelopes included, there is no per-seat license, and building and testing against the sandbox is free. High-volume and white-label deployments get custom volume pricing. Talk to sales for a rate scoped to your expected monthly volume.

Are signatures collected through the API legally binding?

Yes. Signatures collected through the API carry the same legal standing as ones collected in the web app, and are binding under the U.S. ESIGN Act and state UETA laws and under the EU eIDAS regulation. Every completed document is sealed with a SHA-256 hash and a PAdES-B-LT signature carrying an independent timestamp, and ships with a certificate of completion that records each signer's email, IP address, and timestamp on an append-only audit log. That is the same verifiable evidence trail the product produces everywhere else, available to you programmatically.

Is there API documentation and SDKs?

Yes. Approved accounts get the full REST reference covering documents, recipients, fields, templates, and webhooks, with copy-paste examples for each endpoint. The API speaks plain JSON over HTTPS, so it works from any language or framework with an HTTP client, and you can call it directly with curl while you prototype. Language SDKs and a Postman collection are part of the rollout. Request access to get the current reference and your sandbox keys.

Start building

Ship signing in days, not quarters.

Request a free sandbox account, get test and live keys, and integrate against the full REST reference. Pricing is $0.40 per envelope, with plans from $20 a month and 40 envelopes included - you only pay for what you send live.

Free sandbox to build and test Embedded, white-label signing Legally binding · ESIGN, UETA, eIDAS