--- title: "Free E-Signature API for Developers: 5 Signatures a Month | TurboDocx" description: "Send legally binding e-signatures over REST in one call, with 5 free signatures/month, SDKs in 6 languages, and real-time webhooks." url: "https://www.turbodocx.com/e-signature-api" --- # Free E-Signature API for Developers > TurboDocx's e-signature API sends a document for legally binding signature in a single REST call, with a free tier of 5 signatures a month. It returns real-time webhook events like `signature.document.completed` the moment a recipient signs, so you automate what happens next instead of polling for status. Platform stats: 10K+ signatures sent, 5 free signatures a month, 6 published SDKs. ## Key Takeaways - **1 call** sends a document for signature: `POST /turbosign/single/prepare-for-signing` takes a file, recipients, and field positions, and returns a document ID. - **5 free** signatures a month on the $0 Free plan; the $10/mo Team plan raises that to 15/mo shared across the team, and the $20/mo Pro plan is unlimited for named users (60/mo via API key). On every plan, API signatures beyond the included allowance start at $0.30 each with no minimums. - **6 published** SDKs (JavaScript/TypeScript, Python, Go, PHP, Java, Ruby) wrap the same REST API, each installable from its language's standard package registry, including Java on Maven Central. - **7 webhook** event types push real-time status instead of requiring you to poll. Skip the boilerplate: your AI coding agent writes the integration with the Agentic Quickstart Skill. Install it with `npx skills add TurboDocx/quickstart` ([how it works](https://www.turbodocx.com/quickstart.md)). ## What is an e-signature API? An e-signature API (also written esignature API or e-sign API, and often called an electronic signature API) lets your software send documents for signature, track who has signed, and download the signed PDF without anyone opening a separate signing tool. Your application makes the REST calls and your users stay in your workflow. ## Features - **RESTful API**: Send a document, check status, void, resend, and pull the audit trail over simple HTTP endpoints. - **Real-time Webhooks**: 7 event types notify your app when a document is sent, viewed, signed, completed, or voided. - **Legally Binding**: ESIGN Act and UETA compliant signatures with a full audit trail and PAdES-sealed, RFC 3161 timestamped PDFs. - **Template Anchors**: Position signature fields using text anchors like {signature1}, no manual coordinate mapping required. - **6 Published SDKs**: JavaScript/TypeScript, Python, Go, PHP, Java, and Ruby SDKs, all built on the same REST API. - **Flexible Scheduling**: Configurable reminders and expiration windows per document, on top of your org defaults. ## How Do I Send a Document for Signature With an API? Straight from the official SDK examples (production ready). Two SDK examples are shown on the page, TypeScript and Python. ### TypeScript SDK ```typescript // npm install @turbodocx/sdk import { TurboSign } from '@turbodocx/sdk'; TurboSign.configure({ apiKey: process.env.TURBODOCX_API_KEY, orgId: process.env.TURBODOCX_ORG_ID, senderEmail: 'support@yourcompany.com', // required: reply-to + audit trail }); const result = await TurboSign.sendSignature({ file: pdfBuffer, documentName: 'Partnership Agreement', recipients: [ { name: 'Sarah Johnson', email: 'sarah@company.com', signingOrder: 1 } ], fields: [ { type: 'signature', recipientEmail: 'sarah@company.com', template: { anchor: '{signature1}', placement: 'replace', size: { width: 100, height: 30 } } } ] }); // Signing links are emailed to recipients. console.log(result.documentId); ``` ### Python SDK ```python # pip install turbodocx-sdk import asyncio, os from turbodocx_sdk import TurboSign async def send(): TurboSign.configure( api_key=os.getenv("TURBODOCX_API_KEY"), org_id=os.getenv("TURBODOCX_ORG_ID"), sender_email="support@yourcompany.com", # required ) result = await TurboSign.send_signature( file=open("contract.pdf", "rb").read(), document_name="Partnership Agreement", recipients=[ {"name": "Sarah Johnson", "email": "sarah@company.com", "signingOrder": 1} ], fields=[{ "type": "signature", "recipientEmail": "sarah@company.com", "template": {"anchor": "{signature1}", "placement": "replace", "size": {"width": 100, "height": 30}}}], ) # Signing links are emailed to recipients. print(result["documentId"]) asyncio.run(send()) ``` ## How does an integration work from request to signed PDF? 1. **Send the document.** `POST /turbosign/single/prepare-for-signing` with the file, recipients, and field positions. The response includes a document ID. 2. **Listen for status changes.** `POST /api/webhooks` subscribes your endpoint once. TurboDocx then pushes an event as each recipient views and signs, and you verify each payload's HMAC signature on your server. 3. **Handle exceptions.** `POST /turbosign/documents/:documentId/send-reminder` nudges outstanding signers, and the void and resend endpoints cover cancelled or lost requests. 4. **Store the result.** `GET /turbosign/documents/:documentId/download` returns the signed PDF, and the audit trail endpoint returns its record of every action. ## Which Endpoints Does the E-Signature API Have? 9 REST endpoints cover the full signature lifecycle, from send to signed PDF. Base URL: `https://api.turbodocx.com` Sending accepts a `deliverableId` in place of a file, so a document generated with the [Deliverable module](https://www.turbodocx.com/products/api-and-sdk.md) can go straight to signing without a re-upload. | Method | Path | Description | | --- | --- | --- | | POST | `/turbosign/single/prepare-for-signing` | Send a document for signature in one call | | GET | `/turbosign/documents/:id/status` | Check a document's signing status | | GET | `/turbosign/documents/:documentId/recipients` | See who has signed and who you are waiting on | | POST | `/turbosign/documents/:documentId/void` | Cancel a signature request | | POST | `/turbosign/documents/:documentId/resend-email` | Resend the signature request email | | POST | `/turbosign/documents/:documentId/send-reminder` | Nudge outstanding signers | | GET | `/turbosign/documents/:documentId/audit-trail` | Pull the full audit trail | | GET | `/turbosign/documents/:documentId/download` | Download the signed PDF | | POST | `/api/webhooks` | Subscribe to signature events | ## Which Languages Have an E-Signature SDK? Every SDK wraps the same REST API and ships at version 0.9.0. Pick a language and follow its step-by-step guide. | Language | Install | Guide | | --- | --- | --- | | JavaScript / TypeScript | `npm install @turbodocx/sdk` | [Guide](https://www.turbodocx.com/guides/sign-documents-with-typescript.md) | | Python | `pip install turbodocx-sdk` | [Guide](https://www.turbodocx.com/guides/sign-documents-with-python.md) | | PHP | `composer require turbodocx/sdk` | [Guide](https://www.turbodocx.com/guides/sign-documents-with-php.md) | | Go | `go get github.com/TurboDocx/SDK/packages/go-sdk` | [Guide](https://www.turbodocx.com/guides/sign-documents-with-go.md) | | Java | `implementation 'com.turbodocx:turbodocx-sdk:0.9.0'` | [Guide](https://www.turbodocx.com/guides/sign-documents-with-java.md) | | Ruby | `gem install turbodocx-sdk` | [Guide](https://docs.turbodocx.com/docs/SDKs/ruby) | ## How Do I Know When a Document Is Signed? 7 webhook event types cover the signature lifecycle. Subscribe once with `POST /api/webhooks` and TurboDocx pushes an HMAC-signed payload to your endpoint on every status change. - `signature.document.sent` - `signature.document.viewed` - `signature.document.recipient_signed` - `signature.document.signed` - `signature.document.completed` - `signature.document.finalization_failed` - `signature.document.voided` ## Are E-Signatures Sent Through the API Legally Binding? Every signature is ESIGN Act and UETA compliant. 1 audit trail entry is logged per action (viewed, signed, completed) with IP address and timestamp. Completed PDFs are sealed with a PAdES-compliant certificate and an RFC 3161 timestamp, so the signed document's integrity holds up independently after delivery. ## Built for SaaS Platforms 1 API key sends and tracks signature requests programmatically, no per-seat TurboDocx login required. For a fully embedded, white label signing experience under your own brand, see [embedded and white label e-signatures](https://www.turbodocx.com/embed-electronic-signature.md), a separate layer built on this same API. Serving many customers? The [white-label e-signature API](https://www.turbodocx.com/white-label-esignature-api.md) covers your sender identity on every request and an isolated organization per customer. - Send documents for signature via API key, not a UI login - Template-based field positioning with text anchors - Real-time status via webhooks instead of polling - Embedded, white label signing available as an add-on ## For Enterprises Most teams self-serve with the API and SDKs above. If your Salesforce, SharePoint, or legacy ERP setup needs a custom signing flow built and maintained for you, our team delivers that as a tailored integration, at software pricing, not agency rates. Rather send from Salesforce with no code? The free [Salesforce e-signature app](https://www.turbodocx.com/integrations/salesforce-esignature.md) adds a Send for Signature button to the record. - ESIGN Act and UETA compliant signatures - PAdES-sealed, RFC 3161 timestamped PDFs - Dedicated support and custom API rate limits ## What Is the Difference Between an Electronic Signature API and a Digital Signature API? The two terms overlap in search but mean different things. Under the U.S. ESIGN Act, an electronic signature is ["an electronic sound, symbol, or process, attached to or logically associated with a contract or other record and executed or adopted by a person with the intent to sign the record"](https://www.law.cornell.edu/uscode/text/15/7006). A digital signature is narrower: a cryptographic, certificate-based technique that shows whether a document has changed since it was signed. TurboDocx does both on one API. Signers complete a legally binding electronic signature under the ESIGN Act and UETA, and the completed PDF is then sealed with a PAdES-compliant certificate and an RFC 3161 timestamp, so its integrity can be checked after delivery. If your process requires each signer to hold their own certificate, talk to our team before you build. ## How Much Does an E-Signature API Cost? API plans start at $0.30 per signature, with no minimums. Start on the free plan and pay only for the signatures you send beyond it, so a month with one extra signature costs $0.30. | Plan | Price | Detail | | --- | --- | --- | | Free | $0 | 5/mo signatures | | Team | $10/user/mo | 15/mo signatures, shared in-app + API | | Pro | $20/user/mo | Unlimited in-app; 60/mo via API key, then from $0.30 per signature (no minimums) | | Enterprise | Contact us | Custom API rate limits | Full details: [pricing](https://www.turbodocx.com/pricing.md). ## Frequently Asked Questions ### How much does the TurboDocx e-signature API cost? $0 to start: the Free plan includes 5 signatures a month through the API or the app, no credit card required. The $10/user/month Team plan raises that to 15 signatures a month, shared between in-app and API-key usage. The $20/user/month Pro plan gives named users unlimited signatures in the app; programmatic API-key access on Pro includes 60 signatures a month. On every plan, API signatures beyond the included allowance start at $0.30 each with no minimums. Enterprise plans negotiate custom API rate limits. ### Is there a free e-signature API? 5 signatures a month are free on the TurboDocx Free plan, sent through the same production API and SDKs as paid plans, with no credit card required. Create an account at app.turbodocx.com, generate an API key, install an SDK for your language, and send your first document in one call. ### Can I set a signing order for multiple signers? 1 field per recipient sets it: give each recipient a signingOrder of 1, 2, 3 and so on, and TurboSign sends the document to each signer in that order, so an employee can sign before HR countersigns. A webhook event fires as each recipient signs and again when the document is completed. ### Can I send documents for signature in bulk through the API? 4 endpoints make up the TurboSign Bulk API: POST /turbosign/bulk/ingest creates a batch of send operations, two GET endpoints list your batches and the jobs inside a batch, and a cancel endpoint stops a batch and its pending jobs. The Bulk API guide at docs.turbodocx.com covers the request format and per-document settings. ### Does the TurboDocx e-signature API support webhooks? 7 webhook event types cover the signature lifecycle: sent, viewed, recipient_signed, signed, completed, finalization_failed, and voided. Subscribe once with a POST to /api/webhooks and TurboDocx pushes a signed HTTP payload to your endpoint the moment a status changes, so your app reacts in real time instead of polling. Each payload carries an HMAC signature you verify server-side. ### Is there a PHP SDK for the TurboDocx e-signature API? 1 command installs it: composer require turbodocx/sdk. The official PHP SDK wraps the same REST endpoints as the JavaScript/TypeScript, Python, Go, Java, and Ruby SDKs, including sending a document for signature, checking its status, voiding, resending, and pulling the audit trail. The step-by-step PHP guide at /guides/sign-documents-with-php walks through a working send-for-signature example. ### Are e-signatures sent through the TurboDocx API legally binding? 1 audit trail entry is logged for every action on a document: viewed, signed, completed, each with an IP address and timestamp, retrievable through the audit trail endpoint. Signatures are ESIGN Act and UETA compliant, and completed PDFs are sealed with a PAdES-compliant certificate plus an RFC 3161 timestamp, so a signed document's integrity holds up independently after delivery. ### Is the TurboDocx e-signature API also a digital signature API? 2 layers cover both terms: signers complete a legally binding electronic signature under the ESIGN Act and UETA, and the completed PDF is sealed with a PAdES-compliant certificate and an RFC 3161 timestamp. That certificate seal is the digital signature layer, and it lets anyone check that the document has not changed since it was signed. ### Can I white label the e-signature API for my SaaS platform? 1 API key is what a SaaS platform needs to send and track signature requests programmatically, no per-seat TurboDocx login required. For a fully embedded, white label signing experience under your own brand, with no redirect to a TurboDocx-hosted page, see /embed-electronic-signature, a separate embedding layer built on top of this same signing API. For sender identity and one isolated organization per customer, see /white-label-esignature-api. ## Related Resources - [Document Automation API & SDK](https://www.turbodocx.com/products/api-and-sdk.md): Generate DOCX, PPTX, and PDF documents from templates with the same SDK. - [Developer Hub](https://www.turbodocx.com/developers.md): All TurboDocx SDKs, quickstarts, and the AI agent install skill in one place. - [Best E-Signature APIs Compared](https://www.turbodocx.com/best-esignature-api-comparison.md): Side-by-side comparison of e-signature API providers for developers. Need a tailored integration into your existing stack instead of a self-serve API? [Book a demo](https://www.turbodocx.com/demo?product=turbosign). Questions: [Discord](https://discord.gg/NYKwz4BcpX), docs at [docs.turbodocx.com](https://docs.turbodocx.com). Get your API key in minutes. 5 free signatures a month, no credit card required, 5 min setup. [Get an API key](https://app.turbodocx.com/signup)