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.
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.
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.
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.
Send from reusable templates with fields already placed, or position signature, date, and form fields by coordinates at send time. Same result every time.
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.
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.
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.
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.
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.
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.
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.
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
}'/v1/documentsCreate and optionally send a document/v1/documents/:id/recipientsSet signers and signing order/v1/documents/:id/fieldsPlace signature and form fields/v1/documents/:id/sendSend for signature/v1/documents/:idCheck status and recipients/v1/documents/:id/files/signedDownload the sealed PDF/v1/templates/:id/sendSend from a reusable templateEndpoints shown are representative of the REST reference. Approved accounts get the full docs, SDKs, and sandbox keys.
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.sentSent to the first recipient
recipient.viewedA signer opened the document
recipient.signedA signer finished their fields
document.completedAll recipients signed
document.declinedA signer declined to sign
document.expiredThe signing window closed
{
"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"
}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.
Watch envelopes sent this month against your monthly quota, with delivery and completion rates, so billing never surprises you.
Create, rotate, and revoke test and live API keys yourself. Separate sandbox and live keys keep your prototype away from real sends.
See every webhook the API sent, inspect the payload, and replay a delivery that failed - without touching your own logs.
sk_test_9f2c...sk_live_4a1b...document.completedjust nowrecipient.signed2m agorecipient.viewed6m agodocument.sent11m agoSignatures 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.
Flat pricing, billed by usage. $20 a month includes 40 envelopes, and every account starts with a free sandbox to build and test.
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.
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.
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.
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.
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.
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.
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.
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.