E-sign documents online — legally binding. 14-day free trial.

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.

esignature api system with a lock in the middle

QuickSigner › eSignature API

TypeREST API, JSON
AuthenticationOne API key
FilesPDF, DOC, DOCX up to 15 MB
SignaturePAdES with an AATL certificate
Production price$15 per user a month plus $0.30 per sign request
TestingFree developer account
The first 50 sign requests are free, once.

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 buildThe API does it
Secure links for each signer, and remindersOne recipients array. Each signer gets a unique signUrl.
Field placement and the signing screenfields with page and position, and a hosted or embedded signing view.
Cryptographic sealing, certificate chain and timestampA PAdES seal with an AATL certificate and a trusted timestamp, applied on the server.
Audit evidence for disputesA 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.

ParameterWhere it goesWhat it does
hideInfoPanelRequestRemoves the left information panel so the signing view fits your layout.
signedRedirectUrlRecipientSends the signer to your own page after signing.
disable_notifsRecipient optionsStops 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

CapabilityHow it works
TemplatesGET /templates lists your saved templates. Pass a templateId in the sign request and skip the upload.
Seven field typesSignature, stamp, text, checkbox, date, text area and file, each placed by page and position.
Fields from text tagsSet extractTags to true and the API creates fields from tags written in the document text.
Signing orderSet signInOrder to true for sequential signing, or leave it false and everyone signs in parallel.
Your own email wordingsenderName, emailSubject and emailMessage set the sender name, subject and message of the signing email.
Links for SMSAdd "include": ["phone_urls"] to get a shorter phoneUrl for each signer, suited to text messages.
One-click signingWith one_click_sign the signer clicks a signature field that is already placed and filled with their name.
Copy-only recipientsis_copy_only sends a recipient a copy without asking them to sign.
Reminders and cancellingPOST /recipients/{recipientId}/remind reminds a signer. POST /requests/{requestId}/cancel cancels a request that is in progress.
Status trackingGET /requests lists requests and GET /requests/{requestId} returns one in full. A request is IN_PROGRESS, COMPLETED, CANCELED or REJECTED.
WebhooksSet 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 certificateShort-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 monthAPI usage at $0.30Total with one Professional user
50$15$30
100$30$45
250$75$90
500$150$165
More than 500Volume discountAsk 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

More than 500 requests a month

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.

Developers and agencies

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 checkWhy it mattersQuickSigner
Cryptographic standardA 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 certificationShows how the provider protects documents and signing keys.ISO/IEC 27001:2022
Legal frameworksThey must cover the places where your signers are.ESIGN, UETA, eIDAS, GDPR
Pricing modelUsage-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 surfaceTemplates, webhooks, embedded signing and field tags decide how much you build yourself.All four are in the API
Evidence for disputesYou need proof of who signed and when.A signing certificate for every completed request
Testing before payingYou 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.

IndustryWhat platforms send for signature
Real estateLeases, purchase offers, disclosures and listing agreements, signed by tenants, buyers, sellers and agents
Property managementNew leases, renewals, addenda, move-in checklists and owner agreements across a portfolio
HR onboarding and staffingOffer letters, employment agreements, NDAs, policy acknowledgements and staffing assignments
InsuranceApplications, disclosures, endorsements and claim forms from agency, carrier and broker platforms
LendingLoan agreements, disclosures, guarantees and payment authorizations
SaaS customer onboardingOrder 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.

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.

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.

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.

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.

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.

No. Each signer gets a secure link and signs with only an email address and an internet connection.

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.

PDF, DOC and DOCX files of up to 15 MB.

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.

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.

Yes. GET /templates lists your saved templates. Pass a templateId in the sign request and you do not need to upload a file.

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.

Yes. The seal uses a certificate on the Adobe Approved Trust List, so Acrobat and Reader show a valid signature without extra configuration.

Start building with the QuickSigner eSignature API

Free developer account. Unlimited test requests. No credit card required to sign up.

Smiling businesswoman giving a thumbs up — easy, reliable eSigning with QuickSigner
100,000 Documents signed weekly without delay
9/10 Users would recommend us to a friend