eSignature API
Add legally binding electronic signatures to your own app with a REST API. Free developer account for testing, then $0.30 per sign request, with volume discounts above 500 a month.
REST eSignature API
sealed with AATL and PAdES
Your app sends the document. The API handles the signing links, the cryptographic seal and the signing certificate.
The seal uses a certificate on the Adobe Approved Trust List (AATL), the signature follows the PAdES standard, and QuickSigner is ISO/IEC 27001:2022 certified.

QuickSigner › eSignature API
What is an eSignature API?
An eSignature API is a programming interface for the whole signing workflow. Your application sends a document, says who signs it and where, and gets back a completed, tamper-evident PDF with a signing certificate. The signer does not need to leave your product, and you do not write any cryptography.
The QuickSigner eSignature API is a REST API. It takes over four things you would otherwise have to build:
| You would otherwise build | The API does it |
|---|---|
| Secure links for each signer, and reminders | One recipients array. Each signer gets a unique signUrl. |
| Field placement and the signing screen | fields with page and position, and a hosted or embedded signing view. |
| Cryptographic sealing, certificate chain and timestamp | A PAdES seal with an AATL certificate and a trusted timestamp, applied on the server. |
| Audit evidence for disputes | A signing certificate for every completed request. |
Typical uses are a “send contract” button in a CRM, onboarding in a SaaS product, HR offer letters, vendor and NDA workflows, and invoice approvals.
From upload to signed PDF in three steps
Every request carries your API key in the Authorization header. There is no OAuth flow and no token to refresh. The base URL is https://app.quicksigner.com/api/v1.
1. Upload the document
Upload a PDF, DOC or DOCX file of up to 15 MB. The response gives you a fileName for the next call.
curl --request POST \
--url https://app.quicksigner.com/api/v1/files \
--header 'Authorization: YOUR_API_KEY' \
--header 'Accept: application/json' \
--header 'Content-Type: multipart/form-data' \
--form file=@contract.pdf
# Response
{ "fileName": "a1b2c3d4-...-contract.pdf" }2. Create the sign request
Name the signers and place their fields. QuickSigner emails each signer a secure link, and the response includes that link as signUrl.
curl --request POST \
--url https://app.quicksigner.com/api/v1/requests \
--header 'Authorization: YOUR_API_KEY' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--data '{
"fileName": "a1b2c3d4-...-contract.pdf",
"recipients": [
{
"type": "EMAIL",
"email": "jane@example.com",
"name": "Jane Doe",
"fields": [
{ "type": "SIGNATURE", "pageNum": 1,
"x": 100, "y": 600, "width": 180, "height": 60, "required": true }
]
}
],
"senderName": "Acme Corp",
"emailSubject": "Please sign your contract"
}'
# Response (abbreviated)
{ "id": "req_...", "status": "IN_PROGRESS",
"recipients": [ { "id": "rcp_...", "signUrl": "https://app.quicksigner.com/sign/..." } ] }3. Download the signed PDF and its certificate
Signatures are applied asynchronously, so wait for the REQUEST_COMPLETED webhook, then ask for the download links. Both calls return 403 until the request is completed.
# Signed PDF (link valid for about 2 hours)
curl --request GET \
--url https://app.quicksigner.com/api/v1/requests/{requestId}/completed_download_url \
--header 'Authorization: YOUR_API_KEY' \
--header 'Accept: application/json'
# Signing certificate (link valid for about 15 minutes)
curl --request GET \
--url https://app.quicksigner.com/api/v1/requests/{requestId}/download_certificate_url \
--header 'Authorization: YOUR_API_KEY' \
--header 'Accept: application/json'
# Each returns a short-lived download link
{ "requestId": "...", "docUrl": "https://..." }
{ "requestId": "...", "certificateUrl": "https://..." }Embedded signing: keep signers in your app
Load the signUrl of a signer in an iframe inside your own interface. The signer sees no redirect and no new tab, and the signed PDF is the same: the same PAdES seal and the same AATL certificate.
| Parameter | Where it goes | What it does |
|---|---|---|
hideInfoPanel | Request | Removes the left information panel so the signing view fits your layout. |
signedRedirectUrl | Recipient | Sends the signer to your own page after signing. |
disable_notifs | Recipient options | Stops the email to a signer who is already on your screen. |
<iframe
src="https://app.quicksigner.com/sign/..."
width="100%" height="900" style="border:0"
allow="camera; clipboard-write">
</iframe>signedRedirectUrl can fire before the signature is written into the PDF. Use it to move the signer on in your interface, and use the REQUEST_COMPLETED webhook to decide when the signed file is ready.
What the API covers
| Capability | How it works |
|---|---|
| Templates | GET /templates lists your saved templates. Pass a templateId in the sign request and skip the upload. |
| Seven field types | Signature, stamp, text, checkbox, date, text area and file, each placed by page and position. |
| Fields from text tags | Set extractTags to true and the API creates fields from tags written in the document text. |
| Signing order | Set signInOrder to true for sequential signing, or leave it false and everyone signs in parallel. |
| Your own email wording | senderName, emailSubject and emailMessage set the sender name, subject and message of the signing email. |
| Links for SMS | Add "include": ["phone_urls"] to get a shorter phoneUrl for each signer, suited to text messages. |
| One-click signing | With one_click_sign the signer clicks a signature field that is already placed and filled with their name. |
| Copy-only recipients | is_copy_only sends a recipient a copy without asking them to sign. |
| Reminders and cancelling | POST /recipients/{recipientId}/remind reminds a signer. POST /requests/{requestId}/cancel cancels a request that is in progress. |
| Status tracking | GET /requests lists requests and GET /requests/{requestId} returns one in full. A request is IN_PROGRESS, COMPLETED, CANCELED or REJECTED. |
| Webhooks | Set them up on the API page of your account. RECIPIENT_SIGNED fires for each signer and REQUEST_COMPLETED when the document is sealed. |
| Signed PDF and certificate | Short-lived download links for the signed PDF and for the signing certificate of each completed request. |
The interactive API reference has a “Try it” console for every endpoint. The developer guide on GitHub walks through each call with examples.
eSignature API pricing
Testing is free. A developer account lets you create unlimited sign requests, and the completed documents carry a watermark.
Production runs on the Professional plan at $15 per user a month, or $144 per user a year when billed yearly. You pay $0.30 for each sign request, however many people sign it. The first 50 sign requests are free, once.
| Sign requests a month | API usage at $0.30 | Total with one Professional user |
|---|---|---|
| 50 | $15 | $30 |
| 100 | $30 | $45 |
| 250 | $75 | $90 |
| 500 | $150 | $165 |
| More than 500 | Volume discount | Ask for a quote |
The table leaves out the 50 free sign requests. All plans are listed in the pricing section.
Volume discounts and developer commission
Volume discounts
Above 500 sign requests a month, we offer a lower price per request. Tell us how many requests you expect to send each month and we will reply with a price for that volume.
Commission for developers
If you build QuickSigner into products for your clients, we pay you a commission. Tell us about the integrations you build and we will send you the terms.
Legal validity and long-term verification
A signature made through the API is legally binding for most business documents. It is recognized under the US ESIGN Act and UETA and under eIDAS in the EU and UK. Some document types are excluded by law, such as wills and certain property transfers and court filings, so check the rules for those.
Three layers keep a signed PDF verifiable years later:
- PAdES. The signature is embedded inside the PDF, and any change made after signing is detectable.
- AATL certificate. The sealing certificate is on the Adobe Approved Trust List, so Adobe Acrobat and Reader show the signature as valid with no extra software.
- Trusted timestamp. A timestamp from a trusted time authority gives long-term validity, so the signature can still be verified after the signing certificate expires.
You can test this yourself. Complete a sign request, download the PDF and open it in Adobe Acrobat Reader. The signature panel should show a valid signature with no trust warnings.
QuickSigner is ISO/IEC 27001:2022 certified and GDPR compliant, and stores documents encrypted.
How to choose an eSignature API
| What to check | Why it matters | QuickSigner |
|---|---|---|
| Cryptographic standard | A PAdES signature with a timestamp still validates in five years. A pasted signature image with a separate log does not. | PAdES, AATL certificate, trusted timestamp |
| Security certification | Shows how the provider protects documents and signing keys. | ISO/IEC 27001:2022 |
| Legal frameworks | They must cover the places where your signers are. | ESIGN, UETA, eIDAS, GDPR |
| Pricing model | Usage-based and per-seat pricing cross over at different volumes. Model both against your own numbers. | $0.30 per sign request on a $15 plan, with volume discounts above 500 a month |
| Integration surface | Templates, webhooks, embedded signing and field tags decide how much you build yourself. | All four are in the API |
| Evidence for disputes | You need proof of who signed and when. | A signing certificate for every completed request |
| Testing before paying | You should be able to build the whole integration before you pay. | Free developer account, unlimited test requests |
eSignature API by industry
Each industry signs different documents under different rules. These guides map the documents to API options, with integration patterns, code examples, legal limits and costs for each one.
| Industry | What platforms send for signature |
|---|---|
| Real estate | Leases, purchase offers, disclosures and listing agreements, signed by tenants, buyers, sellers and agents |
| Property management | New leases, renewals, addenda, move-in checklists and owner agreements across a portfolio |
| HR onboarding and staffing | Offer letters, employment agreements, NDAs, policy acknowledgements and staffing assignments |
| Insurance | Applications, disclosures, endorsements and claim forms from agency, carrier and broker platforms |
| Lending | Loan agreements, disclosures, guarantees and payment authorizations |
| SaaS customer onboarding | Order forms, MSAs, DPAs and renewals signed inside your product |
eSignature API FAQs
Can I test the eSignature API for free?
Yes. Create a free developer account and enable the API on your My Account page. You can create unlimited sign requests for testing. Completed documents are watermarked until you move to the Professional plan.
How much does the eSignature API cost?
Production use needs the Professional plan at $15 per user a month, plus $0.30 for each sign request, however many people sign it. The first 50 sign requests are free, once.
Are the 50 free sign requests monthly?
No. The 50 free sign requests are a one-time allowance on the Professional plan. After they are used, each sign request costs $0.30.
Do you offer volume discounts?
Yes. If you send more than 500 sign requests a month, contact us with your expected monthly volume and we will send you a price for it.
Do you pay a commission to developers?
Yes. Developers and agencies who build QuickSigner into products for their clients can earn a commission. Contact us and we will send you the terms.
Is a signature made through the API legally binding?
Yes, for most business documents. Signatures are sealed with an AATL certificate using the PAdES standard and are recognized under the US ESIGN Act and UETA and under eIDAS in the EU and UK. Some document types, such as wills, are excluded by law.
Do signers need an account?
No. Each signer gets a secure link and signs with only an email address and an internet connection.
How do I authenticate?
Send your API key in the Authorization header of every request. There is no OAuth flow. Enable the API on your My Account page and the key appears on the API page of your account.
Which file types can I send?
PDF, DOC and DOCX files of up to 15 MB.
Can I embed signing in my own app?
Yes. Load the signUrl returned for a signer in an iframe and set hideInfoPanel to true. The signer stays in your interface and the signed PDF is the same as with email signing.
Does the API support webhooks?
Yes. Configure webhooks on the API page of your account. RECIPIENT_SIGNED fires when a signer signs and REQUEST_COMPLETED when the document is sealed. Build your completion logic on REQUEST_COMPLETED, because signatures are applied asynchronously.
Can I use templates through the API?
Yes. GET /templates lists your saved templates. Pass a templateId in the sign request and you do not need to upload a file.
Are there SDKs?
There are no official SDKs. The API is plain REST with JSON, so it works with any HTTP client in any language. The documentation gives curl examples, and the interactive reference has a “Try it” console for every endpoint.
Will the signed PDF validate in Adobe Acrobat?
Yes. The seal uses a certificate on the Adobe Approved Trust List, so Acrobat and Reader show a valid signature without extra configuration.
Related
- API reference
- Developer guide on GitHub
- eSignature API for real estate
- eSignature API for property management
- eSignature API for HR onboarding and staffing
- eSignature API for insurance
- eSignature API for lending
- eSignature API for SaaS onboarding
- Plans and prices
- Free contract templates
- E-signature pricing in 2026
Prices and features as of October 7, 2026. This page is general information, not legal advice.
Start building with the QuickSigner eSignature API
Free developer account. Unlimited test requests. No credit card required to sign up.




