# SignatureAPI for AI Agents Source: https://signatureapi-daf4ee54.mintlify.app/docs/ai-toolkit/agents Enable your AI agents to send and manage signed document with SignatureAPI. [Model Context Protocol](https://modelcontextprotocol.io/introduction) (MCP) is an open protocol to standardize how applications provide context to LLMs. SignatureAPI provides an MCP server to enable AI agents to send and manage signed documents. This page describes the tools available in SignatureAPI's MCP server, which allows AI agents to interact with the SignatureAPI platform. Our MCP server is currently in private beta. If you're interested in early access, please [get in touch with us](https://signatureapi.com/contact-us). ## Currently available tools Tools are individual operations exposed by the SignatureAPI MCP server. Each tool corresponds to a specific API capability, such as creating an envelope, retrieving a recipient, or uploading a file. These tools are grouped by resource type and can be invoked by LLM agents through the MCP protocol. The table below outlines the currently available tools, the type of resource they act on, their operation type (Read or Write), and direct links to the corresponding REST API documentation for more details. | **Tool** | **Resource** | **Operation** | **Maps to** | | ----------------------- | ------------ | ------------- | ------------------------------------------------------------- | | `create_envelope` | Envelope | Write | [Create envelope](/docs/api/resources/envelopes/create) | | `retrieve_envelope` | Envelope | Read | [Get envelope](/docs/api/resources/envelopes/get) | | `update_envelope` | Envelope | Write | [Update envelope](/docs/api/resources/envelopes/update) | | `list_envelopes` | Envelope | Read | [List envelopes](/docs/api/resources/envelopes/list) | | `cancel_envelope` | Envelope | Write | [Cancel envelope](/docs/api/resources/envelopes/cancel) | | `delete_envelope` | Envelope | Write | [Delete envelope](/docs/api/resources/envelopes/delete) | | `list_envelope_events` | Envelope | Read | [List envelope events](/docs/api/resources/events/envelope) | | `retrieve_recipient` | Recipient | Read | [Get recipient](/docs/api/resources/recipients/get) | | `replace_recipient` | Recipient | Write | [Replace recipient](/docs/api/resources/recipients/replace) | | `resend_recipient` | Recipient | Write | [Resend recipient](/docs/api/resources/recipients/resend) | | `create_ceremony` | Ceremony | Write | [Create ceremony](/docs/api/resources/ceremonies/create) | | `list_recipient_events` | Recipient | Read | [List recipient events](/docs/api/resources/events/recipient) | | `retrieve_deliverable` | Deliverable | Read | [Get deliverable](/docs/api/resources/deliverables/get) | | `create_file` | File | Write | [Create file](/docs/api/resources/files/create) | # Build with AI Source: https://signatureapi-daf4ee54.mintlify.app/docs/ai-toolkit/build Use AI to aid the integration of SignatureAPI into your applications. ## /llms.txt SignatureAPI provides a [/llms.txt](https://llmstxt.org) file that can be accessed at: ``` https://signatureapi.com/llms.txt ``` This file lists all available pages in the SignatureAPI documentation. AI tools can use this file to understand your documentation structure and find relevant content to user prompts. ## /llms-full.txt We also provide a `/llms-full.txt` file that combines SignatureAPI's complete documentation as a single file as context for AI tools. ``` https://signatureapi.com/llms-full.txt ``` This file is large (over 100K tokens). Be mindful of your LLM model’s context limits and usage constraints when processing it. # Authentication Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/authentication Learn how to authenticate your API requests with SignatureAPI SignatureAPI uses **API key authentication** to secure access to your account and ensure only authorized requests can create, modify, or access your envelopes and documents. ## How authentication works All API requests require authentication using an API key passed in the `X-API-Key` header. When you make a request, SignatureAPI validates your API key and determines which account and environment (test or live) the request should access. Your API keys carry many privileges, so be sure to keep them secure! Do not share your secret API keys in publicly accessible areas such as GitHub, client-side code, and so forth. ## Getting your API key You can get a free test API key to try out SignatureAPI and set up your workflow: [Sign up](https://accounts.signatureapi.com/sign-up) for a free account on SignatureAPI. Navigate to the SignatureAPI [Dashboard](https://dashboard.signatureapi.com/settings/api-keys) and copy your test API key from the API Keys section. ## Making authenticated requests Include your API key in the `X-API-Key` header with every request. Here's how to authenticate when creating an envelope: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Employment Agreement", //... } ``` ## API key types SignatureAPI provides different API key types for different environments: | Key Type | Format | Purpose | | --------- | -------------- | ------------------------------------------------------- | | Test keys | `key_test_...` | Development and testing without real legal consequences | | Live keys | `key_live_...` | Production use with legally-binding documents | ### Test mode benefits Test API keys let you create test envelopes, perfect for trying out your workflows. Envelopes in test mode: * Don't send emails to recipients (you can preview them in your dashboard) * Are not legally-binding, so no legal obligations arise during testing * Are completely free to use * Have all the same API functionality as live mode Learn more about [Test Mode](/docs/api/test-mode). ## Authentication errors When authentication fails, you'll receive specific error responses to help you diagnose the issue: ### Invalid API Key The API key provided is not valid or improperly formatted. ```json theme={null} // HTTP Status Code 401 { "type": "https://signatureapi.com/docs/v1/errors/invalid-api-key", "title": "Invalid API Key", "status": 401, "detail": "Please provide a valid API key in the X-API-Key header." } ``` **Common causes:** * Missing or incomplete API key * API key not passed in the `X-API-Key` header * Typos in the API key value [Learn more about Invalid API Key errors](/docs/v1/errors/invalid-api-key) ### Forbidden Access **HTTP Status Code: 403** Your API key is valid but doesn't have permission to access the requested resource. ```json theme={null} // HTTP Status Code 403 { "type": "https://signatureapi.com/docs/v1/errors/forbidden", "title": "Forbidden", "status": 403, "detail": "The requested resource exists, and the API key is valid, but the API key does not have permission to access it." } ``` **Common causes:** * Using an API key from a different account * Insufficient permissions for the requested operation [Learn more about Forbidden errors](/docs/v1/errors/forbidden) ### Test/Live Mode Mismatch **HTTP Status Code: 404** You're trying to access a resource with the wrong environment key (test vs live). ```json theme={null} // HTTP Status Code 200 { "type": "https://signatureapi.com/docs/v1/errors/mode-error", "title": "Mode Error", "status": 403, "detail": "You are trying to access a test-mode resource with a live API key. Please use a test API key." } ``` **Common causes:** * Using a test API key to access live resources * Using a live API key to access test resources [Learn more about Mode errors](/docs/v1/errors/mode-error) ## Next steps Now that you understand authentication, you're ready to: * [Create your first envelope](/docs/api/quickstart) using the API * [Explore the API playground](/docs/api/playground) to test requests interactively # Can I _______ ? Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/can_i Quick answers to common questions about SignatureAPI capabilities including multiple signers, templates, and signature positioning * Can I have multiple signers in my envelope? [Yes!](/docs/api/resources/envelopes/create#param-recipients) * Can I have the signers sign in a specific order? [Yes!](/docs/api/guides/how-to/sequential-signing) * Can I have multiple documents in my envelope? [Yes!](/docs/api/resources/envelopes/create#param-documents) * Can I generate a document from a template and data? [Yes!](/docs/api/resources/documents/templates) * Can I place a signature using coordinates (for fixed-layout forms, for example)? [Yes!](/docs/api/guides/how-to/use-fixed-positions) * Can I place a signature using a placeholder within the document? [Yes!](/docs/api/guides/how-to/use-placeholders) * Can I ask for initials? [Yes!](/docs/api/resources/places/initials) * Can I ask my recipients for information (with input fields)? [Yes!](/docs/api/resources/places/text-input) * Can I get that recipient input through the API? [Yes!](/docs/api/resources/envelopes/captures) * Can I change the language of the signing interface? [Yes!](/docs/api/resources/envelopes/language) * Can I use a different time zone (for example America/New\_York) for timestamps? [Yes!](/docs/api/resources/envelopes/timezone) * Can I use a different date format (for example Month/Day/Year) in timestamps? [Yes!](/docs/api/resources/envelopes/timestamp-format) * Can I have the signing URL so I can send it myself to the recipients? [Yes!](/docs/api/resources/ceremonies/ceremony-url) * Can I redirect the recipient to a URL after signing? [Yes!](/docs/api/resources/ceremonies/redirect-url) * Can I embed the signing interface in my app? [Yes!](/docs/embedded/introduction) * Can I receive a notification when my envelope is completed? [Yes!](/docs/api/webhooks) * Can I retrieve the signed document? [Yes!](/docs/api/resources/envelopes/object#param-url-1) # Concepts Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/concepts Learn the core concepts of SignatureAPI including envelopes, documents, recipients, ceremonies, and deliverables SignatureAPI organizes the document signing process around five core concepts: ```mermaid theme={null} flowchart LR subgraph Envelope B[Documents] C[Recipients] end C -- review and sign Documents during --> D[Ceremony] D -- after completion generates --> E[Deliverable] ``` ## Envelope An [Envelope](/docs/api/resources/envelopes/object) is a container that holds documents and recipients. It organizes and tracks the entire signing workflow from creation to completion. ## Documents [Documents](/docs/api/resources/documents/object) are the files within an envelope that recipients need to review and sign. You can provide PDFs directly or generate documents from [templates](/docs/api/resources/documents/templates) with dynamic data. ## Recipients [Recipients](/docs/api/resources/recipients/object) are the people who interact with the envelope. Each recipient has a [type](/docs/api/resources/recipients/object#types) (signer, approver, or preparer) that determines what actions they can perform. ## Ceremony A [Ceremony](/docs/api/resources/ceremonies/object) is a guided session in which a recipient reviews the documents and performs their required actions, such as signing. Each recipient completes their own ceremony, and you can control the [signing order](/docs/api/resources/envelopes/routing) (parallel or sequential). ## Deliverable After all [recipients have completed](/docs/api/resources/recipients/lifecycle) their actions, the [envelope is completed](/docs/api/resources/envelopes/lifecycle). A [Deliverable](/docs/api/resources/deliverables/object) is then generated, containing the signed documents and an audit log. The deliverable is sent to the recipients and is available for download via the API. # Errors Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/errors Handle API errors with RFC 7807 problem details, HTTP status codes, and validation error responses SignatureAPI uses conventional HTTP response codes to indicate the success or failure of an API request. In general: * Codes in the `2XX` range indicate success. * Codes in the `4XX` range indicate problems with the request, like missing parameters. * Codes in the `5XX` range indicate problems with SignatureAPI servers. Errors messages conform to [RFC 7807](https://datatracker.ietf.org/doc/html/rfc7807) and use a Content-Type of `application/problem+json`. ## General Errors This payload is for `4XX` client errors, except validation errors, and `5XX` errors. A URL that identifies the problem type. Visit the URL to learn more about this problem. short, human-readable summary of the problem type The HTTP status code generated by the server for this occurrence of the problem A human-readable explanation specific to this occurrence of the problem. #### Example ```json theme={null} { "type": "https://signatureapi.com/docs/v1/errors/invalid-api-key", "title": "Invalid API Key", "status": 401, "detail": "Please provide a valid API key in the X-API-Key header." } ``` ## Validation Errors This payload is for validation errors (along a `422` status code). A URL that identifies the problem type. Visit the URL to learn more about this problem. short, human-readable summary of the problem type The HTTP status code generated by the server for this occurrence of the problem. For validation errors, this value is always `422`. A human-readable list of specific validation errors. #### Example ```json theme={null} { "type": "https://signatureapi.com/docs/v1/errors/validation-error", "title": "Validation Error", "status": 422, "errors": [ "documents[0].url protocol must be HTTPS", "recipients[0].email must be a valid email address" ] } ``` # Use Custom Authentication Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/custom-authentication Authenticate recipients yourself and redirect them to the signing ceremony from your application With custom authentication, your application handles identity verification before the recipient accesses the signing ceremony. SignatureAPI provides a ceremony URL that you deliver directly, so the recipient can start signing without any additional authentication step on the SignatureAPI side. This approach is useful when: * Recipients are already authenticated in your system. * You want to integrate signing into your existing application flow without interrupting the user experience. * You need a specific authentication method, such as biometrics, SSO, or multi-factor. In this example, we will: 1. Create an envelope with custom authentication on the recipient's `ceremony` object. 2. Set `delivery_type` to `"none"` so the completed deliverable is not automatically emailed to the recipient. 3. Get the ceremony URL from the response and redirect the authenticated user. ## Create the Envelope Set the recipient's `ceremony` object with `authentication` set to `custom`. Provide: * `provider`: The name of your application or company. This appears in the audit log as: "John Doe has been authenticated by \[provider]". * `data`: Key-value pairs that link the signing event to your authentication records. These values are recorded in the envelope audit log. Set `delivery_type` to `"none"` so the completed deliverable is not automatically emailed to the recipient. Your application is responsible for distributing the deliverable. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "documents": [ { "url": "https://pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/dummy-nda.pdf", "places": [ { "key": "client_signature", "type": "signature", "recipient_key": "client" } ] } ], "recipients": [ { "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com", "delivery_type": "none", "ceremony": { "authentication": [ { "type": "custom", "provider": "My App", "data": { "Session ID": "a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3", "User ID": "usr_88620999344", "Authenticated At": "2025-12-31T23:59:59Z" } } ] } } ] } ``` Include enough data in the `data` object to verify how the recipient was authenticated. Useful values include session IDs, user IDs, authentication timestamps, and authentication methods. These values appear in the audit log and may be needed to confirm identity in legal proceedings. ## Get the Ceremony URL The response includes the ceremony URL in `recipients[].ceremony.url`. Because authentication is `custom` (not `email_link`), the URL is available directly in the response. ```json theme={null} // HTTP Status Code 201 { "id": "abcdef12-3456-7890-1234-abcdef123456", "title": "Service Agreement", "recipients": [ { "id": "re_01jxxxxxxxxxxxxxxxxxxxxxxxxx", "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com", "delivery_type": "none", "ceremony": { "authentication": [ { "type": "custom", "provider": "My App", "data": { "Session ID": "a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3", "User ID": "usr_88620999344", "Authenticated At": "2025-12-31T23:59:59Z" } } ], "embeddable_in": [], "redirect_url": null, "redirect_delay": 3, "url_variant": "standard", "url": "https://sign.signatureapi.com/en/start?token=eyJhbGciOiJFUzI1NiIsInR..." }, //... } ], //... } ``` ## Redirect to the Ceremony URL Use the `url` from the ceremony object to redirect the recipient from your application to the signing ceremony. Because your application already authenticated the recipient, they land directly in the signing experience without any additional login step. ``` https://sign.signatureapi.com/en/start?token=eyJhbGciOiJFUzI1NiIsInR... ``` Treat ceremony URLs as sensitive credentials. Do not expose them in logs, public forums, or client-side code where unauthorized users could access them. Deliver the URL only to the authenticated recipient. After the recipient completes signing, SignatureAPI records the authentication event in the envelope audit log, including the provider name and all key-value pairs from the `data` object. ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard. ## Keep Learning * Learn about [custom authentication](/docs/api/resources/ceremonies/authentication/custom) in depth, including audit log details and what data to include. * Explore [ceremony URLs](/docs/api/resources/ceremonies/ceremony-url) for options such as short URLs and URL expiration. * [Embed the signing ceremony](/docs/embedded/introduction) in your application using an iframe. * Learn about other [authentication methods](/docs/api/resources/ceremonies/authentication/overview), such as [email code](/docs/api/resources/ceremonies/authentication/email-code) or [multiple authentication steps](/docs/api/resources/ceremonies/authentication/multiple). # Customize Branding Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/customize-branding Add your company logo, accent color, and email footer to signing ceremonies and recipient emails SignatureAPI lets you apply your company's branding to each envelope individually. Branding covers the signing ceremony interface that recipients see and the emails sent to them throughout the signing process. In this guide, we will create an envelope with: * A company logo displayed in email headers and the signing ceremony. * An accent color applied to buttons and interactive elements. * A custom email footer for legal disclaimers or contact information. ## Upload your Logo Before creating the branded envelope, upload your logo to your account's Library. Only files uploaded to your Library can be used as logos; external URLs are not supported. Your logo must meet the following requirements: * **Format:** PNG * **Height:** At least 160px (to avoid pixelation on high-resolution displays) * **File size:** Under 100KB * **Background:** Transparent works best, as logos appear against both white (emails) and gray (signing ceremony) backgrounds Upload your logo using the [Dashboard Library](https://dashboard.signatureapi.com/library), or send it via the API: ```bash theme={null} // POST https://api.signatureapi.com/v1/uploads // X-API-Key: key_test_... // Content-Type: image/png // ``` The response includes a `url` property that looks like `https://api.signatureapi.com/v1/uploads/upl_...`. Copy this URL and use it as the value of the `logo` property when creating your envelope. ## Create a Branded Envelope Include a `branding` object in your envelope creation request: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "documents": [ //... ], "recipients": [ //... ], "branding": { "logo": "https://api.signatureapi.com/v1/uploads/upl_3jBYlxa9gv0fGLzFAnfwxe", "accent_color": "#9810fa", "email": { "footer": "**Disclaimer:** This email and its attachments may contain confidential information. If you are not the intended recipient, please delete it and notify the sender.", "logo_position": "left" } } } ``` ### Branding properties **`logo`** The URL of the logo uploaded to your Library. The logo appears in the header of recipient emails and the signing ceremony. **`accent_color`** A hex color code applied to buttons in emails and the signing ceremony (for example, `#9810fa`). The color must meet a contrast ratio of at least 4.5:1 against white, following [WCAG guidelines](https://www.w3.org/TR/WCAG21/). If the submitted color does not meet this requirement, the API returns an error with a suggested compliant alternative. You can verify your color in advance using the [WebAIM Color Contrast Checker](https://webaim.org/resources/contrastchecker/). **`email.footer`** Text appended to the bottom of all recipient emails, after SignatureAPI's standard footer. Use it for legal disclaimers, privacy notices, or contact information. Supports a subset of Markdown: `**bold**`, `*italic*`, and `\n\n` for paragraph breaks. **`email.logo_position`** Controls the horizontal alignment of the logo in email headers. Accepted values are `left`, `center`, and `right`. Defaults to `left`. Branding applies to the signing ceremony interface and emails sent to recipients (signing requests and completed document delivery). It does not apply to internal notification emails sent to the account owner, or to the signed documents themselves. ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review the branding in your dashboard. ## Keep Learning * Learn about the full [branding object](/docs/api/resources/envelopes/branding) and visual examples of branding applied to emails and the signing ceremony. * Explore the [uploads endpoint](/docs/api/resources/uploads/create) to learn more about uploading files via the API. # Get Deliverables Without the Audit Log Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/deliverable-without-audit-log Generate a clean signed PDF without audit log pages using the simple deliverable type By default, SignatureAPI generates a [standard deliverable](/docs/api/resources/deliverables/standard) that includes the signed documents and a visible audit log. If you need the signed documents without audit log pages, use a [simple deliverable](/docs/api/resources/deliverables/simple) instead. The simple deliverable still embeds the audit log as metadata within the PDF for [verification purposes](/docs/api/resources/deliverables/verification). Only the visible audit log pages are removed. ## Set the deliverable type when creating an envelope Include a `deliverable` object with `type` set to `simple` when creating the envelope. SignatureAPI generates a simple deliverable automatically when the envelope completes. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "documents": [ //... ], "recipients": [ //... ], "deliverable": { "type": "simple" } } ``` ## Generate a simple deliverable after completion If you need both types, or if the envelope already completed with a standard deliverable, create a simple deliverable manually using the [Create Deliverable](/docs/api/resources/deliverables/create) endpoint. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes/{envelope_id}/deliverables // X-API-Key: key_test_... // Content-Type: application/json { "type": "simple" } ``` You can create multiple deliverables for the same envelope. For example, generate a standard deliverable for your records and a simple deliverable to share with the signer. ## Select specific documents Use `included_documents` to include only certain documents from the envelope. This works with both simple and standard deliverables. ```json theme={null} { "type": "simple", "included_documents": ["contract"] } ``` ## Keep Learning * Learn about [deliverable types](/docs/api/resources/deliverables/object) and their differences. * Protect deliverables with a [password](/docs/api/resources/deliverables/password). * [Download signed documents](/docs/api/guides/use-cases/save-signed-documents) automatically using webhooks. # Use Document Templates Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/document-templates Generate personalized documents from DOCX templates and dynamic data Document templates let you create a single DOCX file with merge fields and conditionals, then generate a personalized document for each envelope you send. Instead of editing files manually before each send, you provide the data and SignatureAPI handles the merge. For this example, we will create an envelope with: * One DOCX template containing merge fields for party names and a date. * Two signature places positioned with `[[place_key]]` placeholders. * Two recipients (signers): a service provider and a client. ## Create a Template Create a DOCX file in Microsoft Word and embed merge fields using double curly braces: `{{key}}`. When SignatureAPI processes the envelope, it replaces each field with the matching value from the `data` property you provide. A simple template might look like this:
This Exploration Agreement is entered into as of \{\{date}}, between \{\{serviceProvider.name}} of \{\{serviceProvider.organization}} (the "Service Provider") and \{\{client.name}} of \{\{client.organization}} (the "Client").
You can reference nested objects using dot notation: `{{serviceProvider.name}}` reads the `name` key inside the `serviceProvider` object. To mark where signatures should appear, add `[[place_key]]` placeholders directly in the document. These work the same way as in PDF documents. In this example, the template contains the placeholders `[[provider_signs_here]]` and `[[client_signs_here]]`. DOCX template with merge fields and signature placeholders Templates must be DOCX format. PDF files are not supported for template merging. If you get a [cannot-parse-document](/docs/v1/errors/cannot-parse-document) error, open the file in Microsoft Word and save it again before uploading. Download the DOCX template used in this example. ## Create the Envelope When creating the envelope, set `format` to `docx` on the document object and provide merge values in the `data` property. Also include the `places` array with an entry for each `[[place_key]]` placeholder in the template. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Exploration Agreement", "message": "Please review the agreement and provide your signature.", "documents": [ { "url": "https://pub-e5051420e98a4fdfb3fd42a62fbf06fa.r2.dev/dummy.docx", "format": "docx", "data": { "date": "December 31st, 2025", "serviceProvider": { "name": "Jane Smith", "organization": "ACME Global, Inc." }, "client": { "name": "Michael J. Miller", "organization": "Miller Industries" } }, "places": [ { "key": "provider_signs_here", "type": "signature", "recipient_key": "service_provider" }, { "key": "client_signs_here", "type": "signature", "recipient_key": "client" } ] } ], "recipients": [ { "type": "signer", "key": "service_provider", "name": "Jane Smith", "email": "jane@example.com" }, { "type": "signer", "key": "client", "name": "Michael J. Miller", "email": "michael@example.com" } ] } ``` Key properties on the document object: * `format`: Must be `docx` when using a template. * `data`: An object whose keys match the merge fields in the template. Nested objects are supported. * `places`: An array of place objects. The `key` on each place must match the `[[place_key]]` placeholder in the template. ## Result SignatureAPI merges the template with the provided data and produces a final document. The merge fields are replaced with their values, and the signature places are rendered at the positions marked by the placeholders. Generated document with merged data and signature fields Each recipient receives an email with a link to sign their respective place in the document. ## Conditionals Use conditionals to show or hide sections of the document based on your data. This is useful for clauses that apply only in certain situations, such as a mediation clause that is included only when both parties agree. ### If Use `{{if condition}}` and `{{endif}}` to include a block only when the condition is true. **Template:**
Please read before proceeding. \{\{if showAlert}}
Important: This document is for demonstration purposes only and is not legally binding.
\{\{endif}} By signing, you acknowledge the terms above.
**Data:** ```json theme={null} { "showAlert": true } ``` With `"showAlert": true`, the alert paragraph appears. With `"showAlert": false`, it is omitted entirely. ### If-Else Use `{{if condition}}`, `{{else}}`, and `{{endif}}` to display one of two blocks depending on the value of a condition. **Template:**
\{\{if mediation}}
Any dispute shall be resolved by mediation, with each party bearing its own costs.
\{\{else}}
Any dispute shall be settled by arbitration, and the arbitrator's decision is final.
\{\{endif}}
With `"mediation": true`:
Any dispute shall be resolved by mediation, with each party bearing its own costs.
With `"mediation": false`:
Any dispute shall be settled by arbitration, and the arbitrator's decision is final.
## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard. ## Keep Learning * Learn more about [document template syntax](/docs/api/resources/documents/templates), including all supported field and conditional options. * Explore how to position signatures using [placeholders](/docs/api/guides/how-to/use-placeholders) or [fixed coordinates](/docs/api/guides/how-to/use-fixed-positions). * Learn about other [types of places](/docs/api/resources/places/object), such as [initials](/docs/api/resources/places/initials), [text inputs](/docs/api/resources/places/text-input), or [completion dates](/docs/api/resources/places/date). # Embed Signing in a Mobile App Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/embed-mobile Embed the SignatureAPI signing interface in your mobile app using a WebView You can embed the signing interface directly in your mobile app using a WebView. The signer completes the ceremony inside your app without being redirected to an external browser. You need both: * A **server** to create an envelope and get a ceremony URL. * A **client** (your mobile app) to display the ceremony to the recipient. ## Server Side The server-side setup for mobile embedding is the same as for web embedding. Your server creates an envelope with a recipient whose ceremony uses [Custom Authentication](/docs/api/resources/ceremonies/authentication/custom), then returns the ceremony URL to your mobile app. Follow the server-side steps in the [Embed Signing in a Web App](/docs/api/guides/how-to/embed-web) guide, then return here for the mobile-specific client implementation. Never call the SignatureAPI API directly from your mobile app. Your API key would be exposed in the app bundle. Always fetch the ceremony URL from your own backend. ## Client Side (React Native) ### Install the WebView package Install [react-native-webview](https://github.com/react-native-webview/react-native-webview): ```bash theme={null} npm install react-native-webview ``` ### Build the signing component Create a `SignatureApiWebView` component that loads the ceremony and handles the terminal events: `ceremony.completed`, `ceremony.canceled`, and `ceremony.failed`. Mobile apps use `event_delivery=redirect` instead of `event_delivery=message`. When the ceremony reaches a terminal state, the signing interface redirects the WebView to a `signatureapi-message://` URL. Your app intercepts that navigation and responds accordingly. ```tsx theme={null} import React, { useCallback } from 'react'; import { WebView, WebViewNavigation } from 'react-native-webview'; interface SignatureApiWebViewProps { ceremonyUrl: string; } export function SignatureApiWebView(props: SignatureApiWebViewProps) { const { ceremonyUrl } = props; const [showWebview, setShowWebview] = React.useState(true); // Append query parameters to make the ceremony embeddable. // Use event_delivery=redirect so events arrive as interceptable // navigations rather than JavaScript messages. const embeddedCeremonyUrl = ceremonyUrl + '&embedded=true&event_delivery=redirect'; const handleNavigation = useCallback( (navigationState: WebViewNavigation): void => { try { const parsedUrl = new URL(navigationState.url); // Intercept signatureapi-message:// URLs if (parsedUrl.protocol !== 'signatureapi-message:') return; const eventType = parsedUrl.host; switch (eventType) { case 'ceremony.completed': // The recipient finished signing setShowWebview(false); break; case 'ceremony.canceled': // The recipient canceled the ceremony setShowWebview(false); break; case 'ceremony.failed': // An error prevented the ceremony from completing setShowWebview(false); break; default: console.log(`Unhandled event: ${eventType}`); } } catch (error) { console.error('Error handling navigation:', error); } }, [] ); if (!showWebview) return null; return ( ); } ``` ### Use the component Your app fetches the ceremony URL from your backend and passes it to the component: ```tsx theme={null} // Fetch the ceremony URL from your backend, then render: const ceremonyUrl = 'https://sign.signatureapi.com/en/start?token=eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9...'; ; ``` ### How events are delivered When the ceremony ends, the signing interface issues a redirect to a `signatureapi-message://` URL. The `host` portion of the URL identifies the event type: | URL | Event | | ------------------------------------------- | -------------------------- | | `signatureapi-message://ceremony.completed` | Recipient finished signing | | `signatureapi-message://ceremony.canceled` | Recipient canceled | | `signatureapi-message://ceremony.failed` | An error occurred | For `ceremony.failed`, the URL includes `error_type` and `error_message` query parameters with details about the failure. See [Ceremony Events](/docs/embedded/ceremony-events) for the full reference. ## iOS and Android Native iOS and Android apps follow the same pattern. Load the ceremony URL (with `embedded=true` and `event_delivery=redirect` appended) in a WebView, then intercept navigation to `signatureapi-message://` URLs to handle events. * **iOS (WKWebView):** Implement `webView(_:decidePolicyFor:decisionHandler:)` in your `WKNavigationDelegate`. When the URL scheme is `signatureapi-message`, cancel the navigation and handle the event. * **Android (WebView):** Override `shouldOverrideUrlLoading` in your `WebViewClient`. When the URL scheme is `signatureapi-message`, return `true` and handle the event. ## Try It Use your [test API key](/docs/api/test-mode) to create a test envelope and ceremony. Test envelopes won't send emails, so you can iterate quickly without affecting real recipients. Review the results in your dashboard. ## Keep Learning * Read the [Ceremony Events](/docs/embedded/ceremony-events) reference for the full list of event types and error codes. * Learn how to [customize the signing ceremony](/docs/embedded/customization) to match your app's branding. * See the full [React Native implementation](/docs/embedded/react-native) for additional options, such as hiding the cancel button. * Explore [Custom Authentication](/docs/api/resources/ceremonies/authentication/custom) for details on the server-side ceremony setup required for embedding. # Embed Signing in a Web App Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/embed-web Embed the signing ceremony directly in your web app using an iframe and JavaScript message events This guide shows how to embed the signing ceremony directly in your web application so users can sign documents without leaving your app. The process requires two sides: a **server** that creates the envelope and ceremony using your API key, and a **client** that displays the ceremony inside an iframe. In this example, we will: * Create an envelope with custom authentication, `embeddable_in` set to your domain, and `delivery_type` set to `"none"` so the deliverable is not automatically emailed. * Get the ceremony URL from the response and pass it to your client. * Embed the ceremony URL in an iframe with the required query parameters. * Listen for JavaScript message events to detect when signing is complete. ## Create the Envelope Create an envelope on your server with two important settings on the recipient: * Set `delivery_type` to `"none"` so the completed deliverable is not automatically emailed to the recipient. Your app is responsible for distributing the deliverable. * Set `ceremony.embeddable_in` to the origin where your app is hosted so the signing interface is allowed to load inside your iframe. Use `custom` authentication so the recipient does not need to go through an email flow. Your app handles authentication before presenting the ceremony. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "documents": [ { "url": "https://pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/privacy-placeholder.pdf", "places": [ { "key": "client_signature", "type": "signature", "recipient_key": "client" } ] } ], "recipients": [ { "type": "signer", "key": "client", "name": "Jane Doe", "email": "jane@example.com", "delivery_type": "none", "ceremony": { "authentication": [ { "type": "custom", "provider": "My App", "data": { "user_id": "usr_12345" } } ], "embeddable_in": [ "https://app.example.com" ] } } ] } ``` The response includes the ceremony URL in `recipients[].ceremony.url`. Because authentication is `custom`, the URL is available directly in the response. Pass this URL to your client so it can embed the ceremony. ```json theme={null} // HTTP Status Code 201 { "id": "abcdef12-3456-7890-1234-abcdef123456", "title": "Service Agreement", "recipients": [ { "id": "re_01jxxxxxxxxxxxxxxxxxxxxxxxxx", "type": "signer", "key": "client", "name": "Jane Doe", "email": "jane@example.com", "delivery_type": "none", "ceremony": { "authentication": [ { "type": "custom", "provider": "My App", "data": { "user_id": "usr_12345" } } ], "embeddable_in": [ "https://app.example.com" ], "redirect_url": null, "redirect_delay": 3, "url_variant": "standard", "url": "https://sign.signatureapi.com/en/start?token=eyJhbGciOiJFUzI1NiIsInR..." }, //... } ], //... } ``` Never call the API directly from the client. Your API key would be exposed to anyone using your app, giving them access to all your data in SignatureAPI. Always make API calls from your server and pass the ceremony URL to the client. ## Embed the Ceremony On the client, take the ceremony URL returned by your server and append two query parameters before using it as the iframe `src`: * `embedded=true` - Configures the signing UI for embedding and sets the correct Content Security Policy headers. * `event_delivery=message` - Delivers ceremony events as JavaScript `MessageEvent`s to your page. ```html theme={null} ``` Both query parameters are required. If you omit `embedded=true`, the browser will block the iframe due to Content Security Policy restrictions. If you omit `event_delivery=message`, your page will not receive ceremony events. ## Listen for Events The embedded ceremony sends [JavaScript MessageEvents](https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent) when the signing session reaches a terminal state. Add an event listener on the `window` object to handle these events and update your UI accordingly, for example by closing or hiding the iframe once signing is complete. There are three event types: | Event | Description | | -------------------- | ------------------------------------------------ | | `ceremony.completed` | The recipient completed signing. | | `ceremony.canceled` | The recipient canceled the ceremony. | | `ceremony.failed` | An error prevented the ceremony from completing. | The event type is available as `event.data.type`. For `ceremony.failed` events, `event.data` also includes `error_type` and `error_message`. ```js theme={null} // Function to handle the ceremony completed event function handleCeremonyCompleted(event) { console.log("Ceremony completed successfully."); // For example: hide the iframe and show a confirmation message } // Function to handle the ceremony canceled event function handleCeremonyCanceled(event) { console.log("Ceremony was canceled by the user."); // For example: hide the iframe and return the user to a previous step } // Function to handle the ceremony failed event function handleCeremonyFailed(event) { const { error_type, error_message } = event.data; console.error(`Ceremony failed: ${error_type} - ${error_message}`); // For example: show an error message to the user } // Function to handle incoming message events function handleMessage(event) { const { type } = event.data; switch (type) { case 'ceremony.completed': handleCeremonyCompleted(event); break; case 'ceremony.canceled': handleCeremonyCanceled(event); break; case 'ceremony.failed': handleCeremonyFailed(event); break; default: // Ignore unrecognized message types break; } } // Add event listener to window for message events window.addEventListener('message', handleMessage, false); ``` ## Testing Before integrating the iframe into your application, use the **Embedder** tool to preview how the ceremony will appear: 1. Go to the [Embedder Tool](https://signatureapi.github.io/embedder/). 2. Enter your ceremony URL. The `embedded=true` and `event_delivery=message` query parameters are added automatically. 3. Optionally adjust the width and height in pixels. 4. The tool displays your ceremony in an iframe and shows the events received from it. ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard and use the ceremony URL with the Embedder tool to verify your setup. ## Keep Learning * Learn about [ceremony authentication options](/docs/api/resources/ceremonies/authentication/overview) to control how recipients verify their identity before signing. * Read the full [Embedded Signing introduction](/docs/embedded/introduction) for an overview of embedding in web and mobile apps. * Learn how to [embed signing in a mobile app](/docs/api/guides/how-to/embed-mobile) using WebView. * Explore [ceremony events](/docs/embedded/ceremony-events) to understand all event types and the redirect-based delivery method for mobile apps. # Organize with Topics and Metadata Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/organize-topics-metadata Use topics and metadata together to categorize envelopes and link them to records in your own systems Topics and metadata are two complementary tools for organizing envelopes. Topics categorize envelopes within SignatureAPI, enabling webhook filtering and targeted queries. Metadata stores custom key-value data, such as internal reference IDs or account numbers, that connects envelopes to records in your own systems. Used together, they give you precise control over how envelopes are routed and tracked across both SignatureAPI and your external systems. ## Create an Envelope with Topics and Metadata Set `topics` and `metadata` when creating an envelope: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Sales Contract", "topics": ["sales", "q1_2026"], "metadata": { "crm_opportunity_id": "OPP-20260301", "account_id": "ACC-88421", "sales_rep": "jsmith" }, "documents": [ //... ], "recipients": [ //... ] } ``` Topics and metadata limits: * **Topics:** up to 10 per envelope, lowercase letters, numbers, and underscores only, maximum 32 characters each, must start with a lowercase letter. * **Metadata:** up to 10 key-value pairs, keys up to 32 characters, values up to 1,000 characters. ## Using Topics ### Filter Webhook Notifications Configure a webhook endpoint in the dashboard to receive events only for envelopes that match specific topics. This lets you route different envelope types to separate endpoints or trigger different workflows without building custom routing logic in your backend. For example, a company with separate sales and finance workflows can: 1. Tag sales envelopes with `sales` and finance envelopes with `finance`. 2. Configure one webhook endpoint to receive only `sales` events and another for `finance` events. 3. Each endpoint receives only the notifications relevant to its workflow. A webhook endpoint with no topic filter receives events for all envelopes. Topic filters are available on request. Contact support at [support@signatureapi.com](mailto:support@signatureapi.com) to enable this feature for your account. ### Query Envelopes by Topic Use the `topic` query parameter on the [List Envelopes](/docs/api/resources/envelopes/list) endpoint to retrieve envelopes for a specific topic: ```json theme={null} // GET https://api.signatureapi.com/v1/envelopes?topic=sales // X-API-Key: key_test_... ``` This returns all envelopes tagged with `sales`, making it easy to pull a focused list for reporting, auditing, or processing. ## Using Metadata Metadata is included in all API responses that return an envelope and in every webhook payload under `data.envelope_metadata`. This means you can access your custom data wherever you interact with envelope events, without making additional API calls to look up related records. When a recipient signs, SignatureAPI sends a `recipient.completed` webhook that includes the envelope's metadata: ```json theme={null} { "id": "evt_4p2oouvNvjp1I9ckgqycH2", "type": "recipient.completed", "timestamp": "2026-03-01T15:00:01.999Z", "data": { "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "crm_opportunity_id": "OPP-20260301", "account_id": "ACC-88421", "sales_rep": "jsmith" }, //... } } ``` Use the metadata values in your webhook handler to update the corresponding record in your CRM, trigger a downstream workflow, or route the notification to the right service. Do not store sensitive information (such as bank account numbers, card details, or passwords) as metadata. ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard. ## Keep Learning * Learn more about [topics](/docs/api/resources/envelopes/topics), including all formatting rules and webhook filter configuration. * Learn more about [metadata](/docs/api/resources/envelopes/metadata), including limits and additional usage examples. * Set up [webhooks](/docs/api/webhooks) to receive real-time envelope events in your backend. # Multiple Recipients Signing In Parallel Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/parallel-signing Send envelopes to multiple recipients simultaneously so they can sign in any order When sending an envelope for signatures, you can control how it's sent to recipients using the `routing` property in the **[Envelope](https://signatureapi.com/docs/resources/envelopes/object#param-routing)**. There are two options: **Sequential** and **Parallel**. By default, SignatureAPI uses sequential routing. With **Parallel Routing**, the envelope is sent simultaneously to all recipients. Each recipient can sign the document whenever they want, and there is no required signing order. In this example, we will create an envelope with: * A single PDF document. * Two recipients (signers) signing in parallel, with the keys `disclosing_party` and `receiving_party`. * Two signature places positioned with placeholders `[[disclosing_party_signature]]` and `[[receiving_party_signature]]`. All other envelope settings use the default configuration: * The recipient will receive an email with a link to sign. * The account's default language, timezone, and timestamp format used. ## Prepare your Document Placeholders are text markers within your PDF document indicating specific locations for items such as signatures, initials, or text inputs. Each placeholder follows the format `[[place_key]]`, where `place_key` uniquely identifies the specific location within your document. In this example, we have prepared a document containing the placeholders `[[disclosing_party_signature]]` and `[[receiving_party_signature]]`. These placeholders mark the exact positions within the document where the signatures corresponding to each key (`disclosing_party_signature` and `receiving_party_signature`) will be inserted. Download the PDF used in this example. In our document, the placeholder is highlighted in blue for visibility. However, we recommend setting it to white so it remains invisible to the signer. ## Create the Envelope When creating the envelope: * Set `routing` to `parallel`. * Add your recipient objects to the recipients property of the Envelope in any order, as they'll be sent simultaneously. * Add the signature place objects to the `places` array inside the document object: * `key`: Must match the placeholder within the document file (e.g., `disclosing_party_signature`). * `type`: Set as `signature`. * `recipient_key`: Matches recipient keys (`disclosing_party` and `receiving_party`). ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-Api-Key: { "title": "Dummy NDA", "message": "Please review and sign the following Non-Disclosure Agreement (NDA) for internal testing purposes. This document is not legally binding and is used solely for demonstration\n\nThank you for your cooperation.", "routing": "parallel", "documents": [ { "url": "https://pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/dummy-nda.pdf", "places": [ { "key": "disclosing_party_signature", "type": "signature", "recipient_key": "disclosing_party" }, { "key": "receiving_party_signature", "type": "signature", "recipient_key": "receiving_party" } ] } ], "recipients": [ { "type": "signer", "key": "disclosing_party", "name": "Jane Doe", "email": "jane@example.com" }, { "type": "signer", "key": "receiving_party", "name": "Richard Roe", "email": "richard@example.com" } ] } ``` ## Result If successful, SignatureAPI will send emails to both Jane Doe ("disclosing\_party") and Richard Roe ("receiving\_party") with links to sign the document. Each signer places their signature on their designated signature line. ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard. ## Keep Learning * Learn about [sequential signing](/docs/api/guides/how-to/sequential-signing) for workflows where the order of signing is important. * Explore other [types of places](/docs/api/resources/places/object), such as [initials](/docs/api/resources/places/initials), [text inputs](/docs/api/resources/places/text-input), or [completion dates](/docs/api/resources/places/date). * Position signatures using [precise coordinates](/docs/api/guides/how-to/use-fixed-positions.mdx). # Prepare a Document Before Sending to Sign Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/prepare-before-signing Use a preparer to fill in document fields before the envelope reaches the signer A **preparer** is a recipient who fills in document fields before the envelope reaches a signer. This is useful when one person needs to populate document data on behalf of another. For example, a sales representative can enter pricing, dates, or contract terms before the customer receives the document to sign. Preparers can complete text inputs, checkboxes, and dropdowns, but cannot add signatures or initials. After filling in all required fields, the preparer clicks **Finish**, and the envelope proceeds to the next recipient. In this example, we will create an envelope with: * A single PDF document. * A preparer (a sales representative) who fills in a text input field with the contract value. * A signer (the customer) who receives the document after the preparer has finished and adds their signature. * Sequential routing so the preparer acts before the signer. ## Prepare your Document Placeholders are text markers within your PDF document indicating specific locations for items such as signatures, initials, or text inputs. Each placeholder follows the format `[[place_key]]`, where `place_key` uniquely identifies the specific location within your document. In this example, we have prepared a document containing two placeholders: * `[[contract_value]]` marks the position where the preparer will enter the contract value as a text input. * `[[customer_signature]]` marks the position where the signer will place their signature. In our document, the placeholders are highlighted in blue for visibility. However, we recommend setting them to white so they remain invisible to recipients. ## Create the Envelope When creating the envelope: * Set `routing` to `sequential` (this is the default, but it is good practice to set it explicitly). * Add recipients in the order they should act. The preparer must appear before the signer in the recipients array. * Add place objects to the `places` array inside the document object: * For the preparer's text input: set `type` to `text_input` and `recipient_key` to the preparer's key. * For the signer's signature: set `type` to `signature` and `recipient_key` to the signer's key. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Sales Agreement", "routing": "sequential", "documents": [ { "url": "https://example.com/sales-agreement.pdf", "places": [ { "key": "contract_value", "type": "text_input", "recipient_key": "sales_rep" }, { "key": "customer_signature", "type": "signature", "recipient_key": "customer" } ] } ], "recipients": [ { "key": "sales_rep", "type": "preparer", "name": "Alex Smith", "email": "alex@company.com" }, { "key": "customer", "type": "signer", "name": "Jordan Lee", "email": "jordan@customer.com" } ] } ``` The `delivery_type` for preparers defaults to `none`, meaning the completed deliverable will not be automatically emailed to the preparer. Set `delivery_type` to `email` if you want SignatureAPI to deliver the completed deliverable by email. ## Result The preparer (Alex Smith) accesses the document first and fills in the contract value field. After clicking **Finish**, the envelope proceeds to the signer. The signer (Jordan Lee) then receives the document with the preparer's field already filled in and can review the completed details before adding their signature. ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard. ## Keep Learning * Learn more about the [preparer recipient type](/docs/api/resources/recipients/preparer) and how it differs from other recipient types. * Explore other [types of places](/docs/api/resources/places/object), such as [checkboxes](/docs/api/resources/places/checkbox), [dropdowns](/docs/api/resources/places/dropdown), or [text inputs](/docs/api/resources/places/text-input). * Learn about [sequential signing](/docs/api/guides/how-to/sequential-signing) for workflows where the order of signing matters. * Learn about [parallel signing](/docs/api/guides/how-to/parallel-signing) for workflows where recipients can sign in any order. # Send an Envelope to an Approver Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/send-to-approver Route an envelope through an approver before it reaches a signer An **approver** is a recipient who reviews and authorizes a document without adding a signature. Use an approver when someone needs to authorize a document before it goes out for a formal signature. Common examples include a manager reviewing a contract before it reaches a client, or a compliance officer checking a document before finalization. In this example, we will create an envelope with: * A single PDF document. * Two recipients: an approver with the key `manager`, followed by a signer with the key `client`. * Sequential routing so the approver acts first. * One signature place assigned to the signer. The approver does not need a signature or initials place. All other envelope settings use the default configuration: * The signer will receive an email with a link to sign after the approver completes their step. * The account's default language, timezone, and timestamp format used. The `delivery_type` for approvers defaults to `none`, meaning the completed deliverable will not be automatically emailed to the approver. Set `delivery_type` to `email` if you want SignatureAPI to deliver the completed deliverable by email. ## Create the Envelope When creating the envelope: * Set `routing` to `sequential` (this is the default, but it is good practice to be explicit). * Add the approver recipient before the signer in the `recipients` array. The order of the array controls the routing order. * Set `"type": "approver"` on the approver recipient. * Add a signature place to the `places` array inside the document object, assigned to the signer only: * `key`: Identifies the place. Must match the placeholder in the document file (e.g., `client_signature`). * `type`: Set to `signature`. * `recipient_key`: Set to the signer's key (`client`). ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "routing": "sequential", "documents": [ { "url": "https://pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/dummy-nda.pdf", "places": [ { "key": "client_signature", "type": "signature", "recipient_key": "client" } ] } ], "recipients": [ { "type": "approver", "key": "manager", "name": "Sarah Chen", "email": "sarah@company.com" }, { "type": "signer", "key": "client", "name": "Michael Torres", "email": "michael@client.com" } ] } ``` ## Result If the request is successful, Sarah Chen (the `manager`) enters the approver ceremony first. She reviews the document and, when satisfied, clicks **Approve**. Approve button A confirmation screen appears once the approval is complete. Approved confirmation After Sarah approves, SignatureAPI routes the envelope to Michael Torres (the `client`). Michael receives an email with a link to sign the document and places his signature on the designated signature line. ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard. ## Keep Learning * Learn about [sequential signing](/docs/api/guides/how-to/sequential-signing) for workflows with multiple signers in a specific order. * Learn about [parallel signing](/docs/api/guides/how-to/parallel-signing) for workflows where signing order does not matter. * Explore the [Approver](/docs/api/resources/recipients/approver) recipient reference for details on delivery and place assignments. * Explore other [types of places](/docs/api/resources/places/object), such as [text inputs](/docs/api/resources/places/text-input) that can be assigned to approvers. # Multiple Recipients Signing Sequentially Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/sequential-signing Route envelopes to recipients one at a time in a specific signing order When sending an envelope for signatures, you can control how it’s sent to recipients using the `routing` property in the **[Envelope](https://signatureapi.com/docs/resources/envelopes/object#param-routing)**. There are two options: **Sequential** and **Parallel**. By default, SignatureAPI uses sequential routing. With **Sequential Routing**, the envelope is sent to one recipient at a time, in the order you specify in the envelope’s recipient array. The next recipient only receives the document after the previous one has signed. * A single PDF document. * Two recipients (signers) signing in sequential order, the first one with the key `disclosing_party` and the second one with the key `receiving_party`. * Two signature places positioned with placeholders `[[disclosing_party_signature]]` and `[[receiving_party_signature]]`. All other envelope settings use the default configuration: * The recipient will receive an email with a link to sign. * The account's default language, timezone, and timestamp format used. ## Prepare your Document Placeholders are text markers within your PDF document indicating specific locations for items such as signatures, initials, or text inputs. Each placeholder follows the format `[[place_key]]`, where `place_key` uniquely identifies the specific location within your document. In this example, we have prepared a document containing the placeholders `[[disclosing_party_signature]]` and `[[receiving_party_signature]]`. These placeholders mark the exact positions within the document where the signatures corresponding to each key (`disclosing_party_signature` and `receiving_party_signature`) will be inserted. Download the PDF used in this example. In our document, the placeholder is highlighted in blue for visibility. However, we recommend setting it to white so it remains invisible to the signer. ## Create the Envelope When creating the envelope: * Set the property `routing` to `sequential` (optional, this is the default). * Add your recipient objects to the recipients property of the Envelope in the order you want. In this example we want the `disclosing_party` to be first, and the `receiving_party` the second, so we must add them in that order in the array. * Add the signature place object for the two places to the `places` array inside the document object, with the following properties: * `key`: This identifies the place within the document. Must match what’s inside the square brackets in the placeholder inside the document file, in this case: `disclosing_party_signature` for the `disclosing_party`, and `receiving_party_signature` for the `receiving_party`. * `type`: As this is a signature place, we use the value `signature`. * `recipient_key`: The key of the recipient that will sign in this place. In this example, `disclosing_party` and `receiving_party` ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-Api-Key: { "title": "Dummy NDA", "message": "Please review and sign the following Non-Disclosure Agreement (NDA) for internal testing purposes. This document is not legally binding and is used solely for demonstration\n\nThank you for your cooperation.", "routing": "sequential", "documents": [ { "url": "https://pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/dummy-nda.pdf", "places": [ { "key": "disclosing_party_signature", "type": "signature", "recipient_key": "disclosing_party" }, { "key": "receiving_party_signature", "type": "signature", "recipient_key": "receiving_party" } ] } ], "recipients": [ { "type": "signer", "key": "disclosing_party", "name": "Jane Doe", "email": "jane@example.com" }, { "type": "signer", "key": "receiving_party", "name": "Richard Roe", "email": "richard@example.com" } ] } ``` ## Result If the request is successful, SignatureAPI will send Jane Doe (the "disclosing\_party") an email with a link to sign, while Richard Roe (the "receiving\_party") will remain in `awaiting` status until Jane completes. Jane will click the link and place her signature on the signature line. After Jane completes, SignatureAPI will send Richard Roe (the "receiving\_party") an email with a link to sign. Richard will click the link, and will be able to place his signature on his signature line. ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard. ## Keep Learning * Learn about [parallel signing](/docs/api/guides/how-to/parallel-signing) for workflows where the order of signing is not important. * Explore other [types of places](/docs/api/resources/places/object), such as [initials](/docs/api/resources/places/initials), [text inputs](/docs/api/resources/places/text-input), or [completion dates](/docs/api/resources/places/date). * Position signatures using [precise coordinates](/docs/api/guides/how-to/use-fixed-positions.mdx). # Set Up Webhooks Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/set-up-webhooks Receive real-time event notifications from SignatureAPI in your own backend Webhooks let you receive real-time notifications when events happen in your SignatureAPI account, such as when a recipient signs, an envelope completes, or an email bounces. Instead of polling the API, SignatureAPI sends an HTTP `POST` request to your endpoint each time an event occurs. ## Create a Webhook Endpoint Webhook endpoints are registered in the Dashboard. You can create separate endpoints for [test and live](/docs/api/test-mode) modes, and choose which event types each endpoint receives. Go to [Dashboard > Settings > Webhooks](https://dashboard.signatureapi.com/settings/webhooks) and click **Add endpoint**. Create a webhook endpoint in the Dashboard Enter the URL of your webhook endpoint, select the events you want to receive, and save. You can subscribe to individual event types or receive all events. Webhooks are scoped to the mode you are currently viewing in the Dashboard. Make sure you are in the correct mode (test or live) before creating your endpoint. After saving, copy the **Signing Secret** from the right column of your endpoint definition. You will use this to verify that incoming requests are from SignatureAPI. Copy the webhook signing secret from the Dashboard ## Webhook Payload When an event occurs, SignatureAPI sends a `POST` request to your endpoint with the [Event object](/docs/api/resources/events/object) as the JSON body. Here is an example payload for a `recipient.completed` event: ```json theme={null} { "id": "evt_4p2oouvNvjp1I9ckgqycH2", "type": "recipient.completed", "timestamp": "2025-12-31T15:00:01.999Z", "data": { "object_id": "re_7v7Sion0vqjJioYmwfZ9mf", "object_type": "recipient", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "recipient_type": "signer", "recipient_key": "client" } } ``` Every event includes a top-level `id`, `type`, and `timestamp`, along with a `data` object whose shape depends on the event type. The `envelope_metadata` property reflects any custom metadata you attached to the envelope when creating it. Some common event types: | Event type | When it fires | | ------------------------ | ------------------------------------------------------------ | | `envelope.created` | A new envelope is created | | `envelope.started` | The envelope finishes processing and recipients are notified | | `envelope.completed` | All recipients have completed the envelope | | `envelope.canceled` | The envelope is explicitly canceled | | `recipient.completed` | A recipient finishes their signing step | | `recipient.soft_bounced` | A notification email to a recipient bounced | For the full list of event types, see [Envelope Events](/docs/api/resources/events/envelope-events), [Recipient Events](/docs/api/resources/events/recipient-events), [Deliverable Events](/docs/api/resources/events/deliverable-events), and [Sender Events](/docs/api/resources/events/sender-events). ## Verify the Signature Every webhook request includes a `webhook-signature` header. You should always verify this header to confirm the request came from SignatureAPI and was not tampered with. SignatureAPI follows the [Standard Webhooks specification](https://github.com/standard-webhooks/standard-webhooks/blob/main/spec/standard-webhooks.md#verifying-webhook-authenticity) for signature verification. The Standard Webhooks project provides verification libraries for most languages, so you do not need to implement the HMAC logic yourself. For example, to verify signatures in JavaScript or TypeScript: ```js theme={null} import { Webhook } from "standardwebhooks" const wh = new Webhook(signing_secret); wh.verify(webhook_payload, webhook_headers); ``` Libraries are available for [JavaScript and TypeScript](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/javascript), [Python](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/python), [Java and Kotlin](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/java), [Rust](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/rust), [Go](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/go), [Ruby](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/ruby), [PHP](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/php), [C#](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/csharp), and [Elixir](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/elixir). Use the Signing Secret you copied from the Dashboard as the `signing_secret` value. ## Respond to Webhooks Your endpoint must return a response with a status code in the `2XX` range (200 to 299) to acknowledge that the event was received successfully. Any other status code is treated as a failed delivery. SignatureAPI does not guarantee the order of event delivery. Your endpoint should handle events arriving out of order. If delivery fails, SignatureAPI will retry for up to 48 hours using an exponential backoff strategy. If your endpoint consistently fails over several days, the account owner will be notified and deliveries to that endpoint may be temporarily disabled. ## Filter by Topic By default, your webhook endpoint receives events for all envelopes in the selected mode. If you need to route events from specific envelopes to a particular endpoint, use topic filters. When creating an envelope, include up to 10 topics in the `topics` array of the [Envelope object](/docs/api/resources/envelopes/object). When configuring your webhook endpoint, specify the topics it should receive events for. Only envelopes tagged with a matching topic will trigger that endpoint. Topic filters are not enabled by default. Contact [support@signatureapi.com](mailto:support@signatureapi.com) to enable this feature for your account. ## Testing These tools are useful for testing your webhook setup before connecting a real backend: * [Webhook.site](https://webhook.site): Generates a temporary endpoint URL and lets you inspect incoming `POST` requests in real time. Useful for verifying the payload structure. * [ngrok](https://ngrok.com/): Creates a secure tunnel from a public URL to your local machine, so you can receive and process webhook events during local development. ## Keep Learning * Review the [Webhooks reference](/docs/api/webhooks) for a complete overview of event delivery, retries, and authentication. * Explore all [event types](/docs/api/resources/events/envelope-events) and their payloads. * Learn about [test mode](/docs/api/test-mode) to safely develop and test your integration without affecting live data. # Use Fixed Positions to Position Signatures Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/use-fixed-positions Position signature fields precisely using page coordinates for fixed-layout documents In SignatureAPI, [places](/docs/api/resources/places/object) are areas in a document where recipients sign, enter information, or where details, such as dates, are automatically added. The [signature place](/docs/api/resources/places/signature) is one of such places. There are two ways to position places: [fixed positions](/docs/api/resources/places/signature#fixed-positions) (coordinates) and [placeholders](/docs/api/resources/places/signature#placeholders) within the document. In this example, we will show how to position a **signature place** using **fixed positions**. For this example, we will create an envelope with: * One recipient (of type `signer`), identified with the key `visitor`. * The visitor signs a single PDF document. * The document will have one signature place, identified with the key `signer_signs_here`, that will be signed by the recipient `visitor` and will be added during the envelope creation using fixed positions. All other envelope settings use the default configuration: * The recipient will receive an email with a link to sign. * The account's default language, timezone, and timestamp format used. ## Prepare your Document The first step in the process is creating a PDF or DOCX file to upload. For this example, we prepared a document, where we put a line in the second page where we would like to place the signature. Download the PDF used in this example. ## Locate the Coordinates Fixed positions can be defined by specifying the page number, along with distances from the top of the page (`top`) and from the left side of the page (`left`), measured in points (1/72 of an inch). One of the main problems when using Fixed Positions is finding the exact coordinates. You can use any tool that indicates the position in points like image editors, or build your own. For this task, SignatureAPI provides a [simple tool](https://cucho.github.io/place-positioner/) that helps, just open the file and click on the point you want. The `key` of the place will be `signer_signs_here`, and the position will be available at the sidebar. ## Create the Envelope When creating the envelope, add the array of fixed positions inside the document, and add the signature place object to the `places` array inside the document object, with the following properties: * `key`: Identifies the place within the document. Must match what you decided to use, in this case: `signer_signs_here`. * `type`: As this is a signature place, use the value `signature`. * `recipient_key`: The key of the recipient who will sign. Here, it's `visitor`. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-Api-Key: { "title": "Dummy Consent", "message": "Please review and sign the Dummy Privacy Policy for internal testing purposes. This document is not legally binding and is used solely for demonstration\n\nThank you for your cooperation.", "documents": [ { "url": "https://pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/privacy-fixed.pdf", "fixed_positions": [ { "place_key": "signer_signs_here", "page": 2, "top": 471, "left": 73 } ], "places": [ { "key": "signer_signs_here", "type": "signature", "recipient_key": "visitor" } ] } ], "recipients": [ { "type": "signer", "key": "visitor", "name": "John Doe", "email": "john@example.com" } ] } ``` ## Result If successful, SignatureAPI will send John Doe (the recipient) an email with a link to sign. John can click the link and place his signature on the signature line. ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard. ## Keep Learning * Learn how to position a signature using [placeholders](/docs/api/guides/how-to/use-placeholders) within the document. * Explore other [types of places](/docs/api/resources/places/object), such as [initials](/docs/api/resources/places/initials), [text inputs](/docs/api/resources/places/text-input), or [completion dates](/docs/api/resources/places/date). # Use Placeholders to Position Signatures Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/how-to/use-placeholders Position signature fields dynamically using text placeholders embedded in your documents In SignatureAPI, [places](/docs/api/resources/places/object) are areas in a document where recipients sign, enter information, or where details, such as dates, are automatically added. The [signature place](/docs/api/resources/places/signature) is one of such places. There are two ways to position places: [fixed positions](/docs/api/resources/places/signature#fixed-positions) (coordinates) and [placeholders](/docs/api/resources/places/signature#placeholders) within the document. In this example, we will show how to position a **signature place** using a **placeholder**. For this example, we will create an envelope with: * One recipient (of type `signer`), identified with the key `visitor`. * The visitor signs a single PDF document. * The document will have one signature place, identified with the key `signer_signs_here`, that will be signed by the recipient `visitor`. All other envelope settings use the default configuration: * The recipient will receive an email with a link to sign. * The account's default language, timezone, and timestamp format used. ## Prepare your Document Placeholders are text within your PDF document that define the location where places (such as signatures, initials, text inputs, etc.) should appear. They follow the format `[[place_key]]`, where `place_key` identifies the place within the document. Place placeholders use double brackets: `[[place_key]]`. Template fields use double curly braces (`{{field_key}}`) to inject content into DOCX documents. A DOCX document can use both. See [Document Templates](/docs/api/resources/documents/templates) for template fields. For this example, we prepared a document that contains the placeholder `[[signer_signs_here]]` to indicate the position of the place with the key `signer_signs_here`. Download the PDF used in this example. In our document, the placeholder is highlighted in blue for visibility. However, we recommend setting it to white so it remains invisible to the signer. ## Create the Envelope When creating the envelope, add the signature place object to the `places` array inside the document object, with the following properties: * `key`: This identifies the place within the document. Must match what’s inside the square brackets in the placeholder inside the document file, in this case: `signer_signs_here`. * `type`: As this is a signature place, we use the value `signature`. * `recipient_key`: The key of the recipient that will sign in this place. In this example, there is just one recipient, who has the key `visitor`. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-Api-Key: { "title": "Dummy Consent", "message": "Please review and sign the Dummy Privacy Policy for internal testing purposes. This document is not legally binding and is used solely for demonstration\n\nThank you for your cooperation.", "documents": [ { "url": "https://pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/privacy-placeholder.pdf", "places": [ { "key": "signer_signs_here", "type": "signature", "recipient_key": "visitor" } ] } ], "recipients": [ { "type": "signer", "key": "visitor", "name": "John Doe", "email": "john@example.com" } ] } ``` ## Result If the request is successful, SignatureAPI will send John Doe (the recipient) an email with a link to sign. John will click the link and will be able to place his signature on top of the signature line. ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard. ## Keep Learning * Learn how to position a signature using [coordinates](/docs/api/guides/how-to/use-fixed-positions) when exact positioning is required. * Explore other [types of places](/docs/api/resources/places/object), such as [initials](/docs/api/resources/places/initials), [text inputs](/docs/api/resources/places/text-input), or [completion dates](/docs/api/resources/places/date). # API Guides Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/overview Step-by-step tutorials and how-to guides for implementing common SignatureAPI workflows ## How-Tos The How-To guides contain practical, step-by-step instructions to help you quickly complete specific tasks using SignatureAPI. ### Signature Positioning Position a signature (or any other place) using a placeholder within the document. Position a signature (or any other place) using fixed positions (coordinates). ### Signing Order How to send an envelope for signatures to multiple recipients in parallel. How to send an envelope for signatures to multiple recipients signing in order. ### Recipients Add an approver who reviews and approves a document before the signer signs it. Have a preparer fill in fields before the signer receives the envelope. Control access to signing ceremonies using your own authentication system. ### Documents & Templates Generate documents from DOCX templates with dynamic data, conditionals, and merge fields. ### Ceremonies Embed the signing ceremony in a web application using an iframe. Embed the signing ceremony in a mobile app using WebView. ### Webhooks Receive real-time notifications when envelope events happen. ### Envelope Management Add your logo, brand colors, and email footer to envelopes. Tag envelopes with topics and attach custom metadata for organization and integration. # Quickstart Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/quickstart Send your first document for signature using the SignatureAPI in this step-by-step tutorial ## Introduction In this quickstart, we'll walk you through sending a simple privacy policy document to Jane Doe (at jane​@​example.com) for her signature. ## Get your API key To get started, [sign up](https://accounts.signatureapi.com/sign-up) for a free test [API key](/docs/api/authentication). This test API key allows you to create [test envelopes](/docs/api/test-mode) without any legal effect and at no cost. ## Create your first envelope An [envelope](/docs/api/resources/envelopes/object) is a container that holds the documents you need to send for signing. Each envelope can include one or more documents and can be sent to one or multiple signers. In this quickstart, we will create an envelope with one document, one recipient, and a single signing place. We’ll use `curl` and the command line for this example. Replace `key_test_xxxxxxxx` in the code snippet below with your test API key (which starts with `key_test_`) and paste it into your command line. ```bash theme={null} curl -X POST \ -H 'Content-Type: application/json' \ -H 'X-API-Key: key_test_xxxxxxxx' \ -d '{ "title": "Dummy Consent", "message": "Please review and sign the attached Dummy Privacy Policy for internal testing purposes. This document is not legally binding and is used solely for demonstration\n\nThank you for your cooperation.", "documents": [ { "url": "https://pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/privacy-placeholder.pdf", "places": [ { "key": "signer_signs_here", "type": "signature", "recipient_key": "visitor" } ] } ], "recipients": [ { "key": "visitor", "type": "signer", "name": "Jane Doe", "email": "jane@example.com" } ] }' \ https://api.signatureapi.com/v1/envelopes ``` This request creates an envelope titled `Dummy Consent` with a message `"Please review..."` that will be included in the emails sent to the recipient. The envelope has one recipient, identified by the key `visitor`. This recipient is a signer named `Jane Doe`, with the email `jane@example.com`. The envelope contains one document, a PDF hosted at `https://pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/privacy-placeholder.pdf`. The document includes a place for the recipient `visitor` to sign. The placeholder is of type `signature` and links to the placeholder `[[signer_signs_here]]` inside the PDF document. Once you've sent the request, you should see a response like this (formatted for readability): ```JSON theme={null} { "id": "69b50512-a771-4bdf-5555-12c555590aa2", "title": "Dummy Consent", "label": null, "message": "Please review and sign the attached Dummy Privacy Policy for internal testing purposes. This document is not legally binding and is used solely for demonstration\n\nThank you for your cooperation.", "status": "processing", "language": "en", "timezone": "UTC", "timestamp_format": "MM/DD/YYYY hh:mm:ss", "mode": "test", "routing": "sequential", "deliverable": null, "topics": [], "metadata": {}, "sender": { "name": "Richard Roe", "email": "richard@example.com", "organization": null }, "documents": [ { "id": "doc_7C4In8kXXYYf4kfkiUce94", "envelope_id": "69b50512-a771-4bdf-5555-12c555590aa2", "title": null, "page_count": 2, "url": "https: //pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/privacy-placeholder.pdf", "format": "pdf", "data": null, "fixed_positions": [], "places": [ { "key": "signer_signs_here", "type": "signature", "recipient_key": "visitor" } ] } ], "recipients": [ { "id": "re_0RKFGQ8EgXXYYKq854c045", "envelope_id": "69b50512-a771-4bdf-5555-12c555590aa2", "type": "signer", "key": "visitor", "name": "Jane Doe", "email": "jane@example.com", "ceremony": { "authentication": [ { "type": "email_link", "subject_override": null, "message_override": null } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": null }, "delivery_type": "email", "ceremony_creation": "automatic", "signature_options": ["typed", "drawn"], "status": "pending", "completed_at": null, "status_updated_at": "2025-12-31T23:59:59.000Z" } ], "created_at": "2025-12-31T23:59:59.000Z", "completed_at": null } ``` ## Check the sent email Although test API keys don't send real emails, you can view the email that would be sent in the Dashboard. 1. Log in to your Dashboard 2. Navigate to the **Envelopes** list and select your newly created envelope. Select your envelope in the dashboard In the envelope details, scroll down to the **Emails** section and click on the email sent to Jane Doe. Display envelope You'll be able to preview the email and see how it would appear if it were sent to the recipient. In test mode, however, emails are not actually sent to recipients. Display envelope Click on the blue button in the email preview to go to the signing ceremony as Jane. ## Sign the envelope as Jane Now, you'll step into Jane Doe’s shoes as the signer. Go through the signing ceremony and sign the document as Jane would. Display envelope ## Check the envelope in the API Once Jane has signed the document, let’s check the status of the envelope and the recipients to make sure everything is moving along smoothly. To do this, we'll use the following curl command to retrieve the envelope’s status. Replace the API key with your test key and `00000000-0000-0000-0000-000000000000` with the envelope ID you received earlier. ```bash theme={null} curl -X GET \ -H 'X-API-Key: key_test_xxxxxxxx' \ https://api.signatureapi.com/v1/envelopes/00000000-0000-0000-0000-000000000000 ``` The response will look something like this (we redacted some of the parts that didn't change): ```JSON theme={null} { "id": "3cd512e8-0db8-4608-af95-bfcf9dd08620", "status": "completed", // ... "deliverable": { "id": "del_2gejfUSFk9H0dF20KklS2y", "envelope_id": "3cd512e8-0db8-4608-af95-bfcf9dd08620", "status": "processing", "type": "standard", "language": "en", "timezone": "UTC", "timestamp_format": "DD/MM/YYYY HH:mm:ss", "url": null }, // ... "recipients": [ { "id": "re_1RIbLpPWJL44QTBY6n8jBW", "envelope_id": "3cd512e8-0db8-4608-af95-bfcf9dd08620", "type": "signer", "key": "visitor", // ... "status": "completed", "completed_at": "2024-09-04T19:31:05.188Z", "status_updated_at": "2024-09-04T19:31:05.438Z" } ], "created_at": "2024-09-04T19:30:24.822Z", "completed_at": "2024-09-04T19:31:05.188Z" } ``` Here’s what to check: * **Recipient Status**: Inside the `recipients` array, the status should be marked as `completed`. This confirms Jane signed the document. * **Envelope Status**: The envelope (root) object's status should also be set to `completed`, meaning the envelope process is finished as all the recipients signed the envelope. * **Deliverable Status**: The deliverable object may initially show a `processing` status, which indicates SignatureAPI is still generating the final signed document. This can take up to two minutes. You can repeat the GET request to check when it's ready. Once completed, the deliverable status will change to `generated`: ```JSON theme={null} { //... "deliverable": { "id": "del_2gejfUSFk9H0dF20KklS2y", "envelope_id": "3cd512e8-0db8-4608-af95-bfcf9dd08620", "status": "generated", "type": "standard", "language": "en", "timezone": "UTC", "timestamp_format": "DD/MM/YYYY HH:mm:ss", "url": "https://s3.us-east-2.amazonaws.com/signatureapi-vault/envelopes/3cd512e8-0db8-4608-af95-bfcf9dd08620/deliverables/del_2gejfUSFk9H0dF20KklS2y/sealed.pdf?..." }, //... } ``` ## Check the envelope in the dashboard The deliverable is also sent to the recipients. In this case, Jane. To view the email Jane received with the completed document, follow these steps: 1. Go to the envelope page in your Dashboard. 2. Verify that the envelope is marked as completed. 3. In the "Emails" section, you'll see all the emails related to this envelope. Look for the one sent to Jane titled: "Completed: Dummy Consent." Display envelope You’ll also notice that two additional notifications were sent to the account owner (Richard Roe). These notify you that Jane signed the envelope and that the envelope process is fully completed. From the envelope page, you can download the signed document (the deliverable) by clicking the download button. ## What's Next You’ve just scratched the surface of what SignatureAPI can do. Here are a few powerful features you can explore: * Add multiple [documents](/docs/api/resources/documents/object) and [recipients](/docs/api/resources/recipients/object) to a single envelope for more complex workflows. * [Customize envelope branding](/docs/api/resources/envelopes/branding) with your company logo, colors, and email customizations for a professional experience. * [Embed the signing interface](/docs/embedded/introduction) directly into your web or mobile application, giving users a seamless experience. * [Generate documents from templates](/docs/api/resources/documents/templates) with customizable fields and conditional logic for dynamic document creation. * [Upload documents and templates](/docs/api/resources/uploads/create) to SignatureAPI, so you don’t have to host them yourself. * Add [signatures](/docs/api/resources/places/signature), [dates](/docs/api/resources/places/date), or text fields to documents using either [placeholders](/docs/api/resources/places/positioning#placeholders) or [fixed positions](/docs/api/resources/places/positioning#fixed-positions) for precise placement. * Use [webhooks](/docs/api/webhooks) to receive real-time notifications in your application when events happen. * Customize the [language](/docs/api/resources/envelopes/language) of recipient interfaces and emails to match your audience. * Adjust the [timestamp formats](/docs/api/resources/envelopes/timestamp-format) and [time zones](/docs/api/resources/envelopes/timezone) to suit your location and preferences. # Send Bulk Envelopes Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/use-cases/bulk-envelopes Send multiple personalized envelopes programmatically from a data set When you need to send the same document to many recipients with personalized details (for example, renewal notices, offer letters, or sales proposals), you can loop through your data set and create one envelope per record. This guide shows how to send bulk envelopes using a DOCX template and dynamic data. ## How It Works SignatureAPI does not yet have a dedicated bulk-send endpoint. Instead, you create one envelope per recipient by calling `POST /v1/envelopes` for each record in your data set. Each call uses the same DOCX template URL but provides unique data and recipient details. SignatureAPI applies [rate limits](/docs/api/rate-limiting) to API requests. When sending a large batch, add a short delay between requests (for example, 200ms) to stay within the limit. ## Prepare Your Data Structure your data as an array of records. Each record contains the recipient details and any merge fields your template requires. ```js theme={null} const records = [ { name: "Sarah Chen", email: "sarah@example.com", role: "Senior Engineer", start_date: "March 15, 2026" }, { name: "James Wilson", email: "james@example.com", role: "Product Manager", start_date: "April 1, 2026" }, { name: "Maria Garcia", email: "maria@example.com", role: "Design Lead", start_date: "April 15, 2026" } ]; ``` ## Create Envelopes in a Loop For each record, send a `POST /v1/envelopes` request with the record's data. The template URL stays the same across all requests. ```js theme={null} const TEMPLATE_URL = "https://example.com/templates/offer-letter.docx"; const API_KEY = "key_test_..."; for (const record of records) { const response = await fetch("https://api.signatureapi.com/v1/envelopes", { method: "POST", headers: { "X-API-Key": API_KEY, "Content-Type": "application/json" }, body: JSON.stringify({ title: `Offer Letter - ${record.name}`, message: "Please review and sign your offer letter.", documents: [ { url: TEMPLATE_URL, format: "docx", data: { employee_name: record.name, role: record.role, start_date: record.start_date }, places: [ { key: "employee_signature", type: "signature", recipient_key: "employee" } ] } ], recipients: [ { type: "signer", key: "employee", name: record.name, email: record.email } ] }) }); console.log(`Created envelope for ${record.name}: ${response.status}`); // Add a delay to respect rate limits await new Promise(resolve => setTimeout(resolve, 200)); } ``` ## The Envelope Payload Each iteration sends a request like this: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Offer Letter - Sarah Chen", "message": "Please review and sign your offer letter.", "documents": [ { "url": "https://example.com/templates/offer-letter.docx", "format": "docx", "data": { "employee_name": "Sarah Chen", "role": "Senior Engineer", "start_date": "March 15, 2026" }, "places": [ { "key": "employee_signature", "type": "signature", "recipient_key": "employee" } ] } ], "recipients": [ { "type": "signer", "key": "employee", "name": "Sarah Chen", "email": "sarah@example.com" } ] } ``` ## Track Your Envelopes Use the `metadata` property on each envelope to store identifiers from your system (such as a record ID or batch number). This makes it easier to match envelopes back to your data later. ```json theme={null} { "title": "Offer Letter - Sarah Chen", "metadata": { "batch_id": "2026-Q1-offers", "record_id": "emp_001" }, //... } ``` When you receive [webhook events](/docs/api/guides/how-to/set-up-webhooks), the `envelope_metadata` property in the event payload reflects these values. ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard. ## Keep Learning * Learn more about [document templates](/docs/api/guides/how-to/document-templates) and merge field syntax. * Use [webhooks](/docs/api/guides/how-to/set-up-webhooks) to track envelope completion across your batch. * Organize envelopes with [topics and metadata](/docs/api/guides/how-to/organize-topics-metadata) for filtering and reporting. * Review [rate limiting](/docs/api/rate-limiting) to understand request limits. # Mobile and In-Person Signing Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/use-cases/mobile-signing Optimize documents for mobile devices and set up in-person signing on shared tablets SignatureAPI works on any device with a browser. However, standard letter-size PDFs can be difficult to read and sign on small screens. This guide covers how to optimize documents for mobile signing and set up in-person signing on shared devices like tablets. ## Optimizing documents for mobile The key to mobile-friendly signing is creating documents with larger page dimensions and bigger text so the content fills the screen without excessive zooming. ### Page size and layout Instead of standard letter size (8.5" x 11"), create your PDF with a taller, narrower aspect ratio that matches a phone screen. A single-column layout with large text works best. Recommended approach: * **Page size**: Use a custom page size around 6" x 10" or similar portrait ratio. * **Font size**: Use 16pt or larger for body text. * **Margins**: Use generous margins (at least 0.75") so content does not crowd the edges. * **Single column**: Avoid multi-column layouts or side-by-side content. * **Signature place height**: Use the default height of 60 for signature places so they are easy to tap and sign. Download an example document optimized for mobile signing. ### Tips for generating mobile-friendly PDFs If you generate PDFs programmatically: * Set the page dimensions in your PDF library to match a mobile-friendly ratio. * Keep each page short with minimal content so the signer does not need to scroll within a page. * Place signature fields near the bottom of the page where thumbs naturally reach. If you use DOCX templates: * Set the page size in Word under **Layout > Size > More Paper Sizes**. * Use a large font size and generous line spacing. ## In-person signing on shared devices For scenarios where signers are physically present (point of sale, front desk, clinic check-in), you can present the signing ceremony on a shared tablet or kiosk. ### Setup Use [custom authentication](/docs/api/resources/ceremonies/authentication/custom) and [embed the ceremony](/docs/api/guides/how-to/embed-web) in your application. This lets you: * Control when the ceremony is shown on the device. * Skip the email invitation flow entirely. * Record who authenticated the signer in the audit log. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_live_... // Content-Type: application/json { "title": "Check-In Agreement", "documents": [ //... ], "recipients": [ { "type": "signer", "key": "visitor", "name": "Jane Doe", "email": "jane@example.com", "delivery_type": "none", "ceremony": { "authentication": [ { "type": "custom", "provider": "Front Desk", "data": { "verified_by": "staff_member_42", "device": "lobby_tablet_1" } } ], "embeddable_in": ["https://kiosk.yourapp.com"] } } ] } ``` ### Between signers After one signer completes, your application should clear the ceremony from the screen before presenting the next signer's ceremony. Do not reuse ceremony URLs between different signers. ## Keep Learning * [Embed signing in a web app](/docs/api/guides/how-to/embed-web) for iframe setup details. * [Embed signing in a mobile app](/docs/api/guides/how-to/embed-mobile) for WebView integration. * Use [custom authentication](/docs/api/guides/how-to/custom-authentication) to record how signers were verified. * Control [signature place sizing](/docs/api/resources/places/signature#sizing-guide) for touch-friendly fields. # Multi-Tenant Applications Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/use-cases/multi-tenant Integrate SignatureAPI into a multi-tenant SaaS platform where each tenant has its own signing workflows If you are building a SaaS platform where multiple tenants (customers, organizations, or accounts) need to send documents for signature, this guide explains how to structure your integration with SignatureAPI. ## How tenancy works SignatureAPI does not provide scoped API keys, separate projects, or tenant isolation at the API level. Your application uses a single API key and manages tenancy on your side. This means: * **One SignatureAPI account** serves all your tenants. * **Your application** decides which tenant each envelope belongs to. * **Your application** controls which tenants can see which envelopes and deliverables. * **Your end users do not need SignatureAPI accounts.** They interact with your application, which calls the SignatureAPI on their behalf. If scoped API keys or built-in tenant isolation would be valuable for your use case, let us know at [support@signatureapi.com](mailto:support@signatureapi.com). We are evaluating this feature based on demand. ## Use metadata to identify tenants Attach your tenant identifier to each envelope using [metadata](/docs/api/resources/envelopes/metadata). This lets you correlate envelopes with tenants in webhook handlers and when listing envelopes. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_live_... // Content-Type: application/json { "title": "Service Agreement", "metadata": { "tenant_id": "tenant_abc123", "tenant_name": "Acme Corp" }, "documents": [ //... ], "recipients": [ //... ] } ``` When SignatureAPI sends webhook events, the `envelope_metadata` is included in every payload. Use it to route the event to the correct tenant in your system: ```json theme={null} { "type": "recipient.completed", "data": { "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "envelope_metadata": { "tenant_id": "tenant_abc123", "tenant_name": "Acme Corp" }, //... } } ``` ## Use topics to filter webhooks per tenant If different tenants require different webhook handling, use [topics](/docs/api/resources/envelopes/topics) to tag envelopes and configure separate webhook endpoints for each topic. ```json theme={null} { "title": "Service Agreement", "topics": ["tenant_abc123"], "metadata": { "tenant_id": "tenant_abc123" }, //... } ``` ## Per-tenant branding Customize the signing experience for each tenant using the [branding](/docs/api/resources/envelopes/branding) property on each envelope. Set a different logo, accent color, and email footer per tenant. ```json theme={null} { "title": "Service Agreement", "branding": { "logo": "https://api.signatureapi.com/v1/uploads/upl_tenant_abc_logo", "accent_color": "#1a73e8", "email": { "footer": "Sent by Acme Corp via YourApp" } }, //... } ``` ## Per-tenant senders Each tenant can have their own [sender](/docs/api/resources/senders/object) email address. Create and verify a sender for each tenant, then specify it on the envelope. ```json theme={null} { "title": "Service Agreement", "sender": { "name": "Acme Corp", "email": "signing@acmecorp.com", "organization": "Acme Corp" }, //... } ``` The sender's email appears as the Reply-To address in signing request emails. ## Architecture overview A typical multi-tenant integration looks like this: 1. **Tenant creates a document** in your application. 2. **Your server** creates an envelope in SignatureAPI with the tenant's metadata, branding, and sender. 3. **SignatureAPI** handles the signing ceremony with the tenant's recipients. 4. **Webhook events** arrive at your server with the tenant metadata, so you can route them to the correct tenant. 5. **Your server** downloads the deliverable and stores it in the tenant's storage. Your application is the control layer. SignatureAPI handles the signing infrastructure. ## Keep Learning * Use [metadata](/docs/api/resources/envelopes/metadata) to link envelopes to your internal records. * Use [topics](/docs/api/resources/envelopes/topics) to filter webhooks by tenant or category. * Customize the signing experience with [branding](/docs/api/resources/envelopes/branding). * Manage [senders](/docs/api/resources/senders/object) for per-tenant Reply-To addresses. # Download Signed Documents Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/use-cases/save-signed-documents Retrieve signed deliverable PDFs after an envelope completes using webhooks and the deliverables API After all recipients have signed, SignatureAPI generates a deliverable containing the signed document with an embedded audit log. This guide shows how to detect when a deliverable is ready, download the signed PDF, and save it to your own storage. ## Overview The flow works in three steps: 1. SignatureAPI sends a `deliverable.generated` webhook event when the signed document is ready. The event includes a pre-signed download URL. 2. Your server downloads the PDF from the URL in the event payload. 3. Your server saves the file to your storage. ## Step 1: Set Up a Webhook Register a webhook endpoint in the [Dashboard](https://dashboard.signatureapi.com/settings/webhooks) and subscribe to the `deliverable.generated` event. See [Set Up Webhooks](/docs/api/guides/how-to/set-up-webhooks) for detailed instructions. ## Step 2: Handle the Webhook Event When the deliverable is generated, SignatureAPI sends an event with the download URL included directly in the payload: ```json theme={null} { "id": "evt_9k3ppxyQwkr2J0dlhrzCI3", "type": "deliverable.generated", "timestamp": "2026-03-04T15:05:00.000Z", "data": { "object_id": "del_LXRDwyTeJDVrWXmjwxsAGPq", "object_type": "deliverable", "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "envelope_metadata": { "deal_id": "50055" }, "deliverable_type": "standard", "deliverable_name": null, "included_documents": ["contract", "addendum"], "url": "https://vault.signatureapi.com/envelopes/55072f0e-b919-4d69-89cd-e7e56af00530/deliverables/del_LXRDwyTeJDVrWXmjwxsAGPq/sealed.pdf?Signature=..." } } ``` Key properties in `data`: * `url`: A pre-signed download link for the signed PDF. This URL expires after 1 hour. * `deliverable_type`: The type of deliverable (`standard` or `simple`). * `deliverable_name`: The custom name, if one was set when the deliverable was created. * `included_documents`: The document keys included in this deliverable. * `envelope_metadata`: The metadata you attached when creating the envelope. ## Step 3: Download and Save the PDF Use the `url` from the event payload to download the PDF and save it to your storage. Here is a conceptual example: ```js theme={null} app.post("/webhooks/signatureapi", async (req, res) => { const event = req.body; if (event.type === "deliverable.generated") { // Download the signed PDF directly from the event URL const pdfResponse = await fetch(event.data.url); const pdfBuffer = await pdfResponse.arrayBuffer(); // Save to your storage (S3, Azure Blob, local filesystem, etc.) await storage.save( `signed-documents/${event.data.envelope_id}.pdf`, pdfBuffer ); } res.status(200).send("OK"); }); ``` The download URL in the event payload expires after 1 hour. If you need to download the file after the URL has expired, call the [Retrieve Deliverable](/docs/api/resources/deliverables/get) endpoint to get a fresh link. Always [verify the webhook signature](/docs/api/guides/how-to/set-up-webhooks#verify-the-signature) before processing events in production. ## Alternative: Retrieve the Deliverable via API If you prefer to fetch deliverables without relying on the webhook URL, you can call the deliverables endpoint with the deliverable ID from the event: ```json theme={null} // GET https://api.signatureapi.com/v1/deliverables/del_LXRDwyTeJDVrWXmjwxsAGPq // X-API-Key: key_test_... ``` ```json theme={null} // HTTP Status Code 200 { "id": "del_LXRDwyTeJDVrWXmjwxsAGPq", "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "type": "standard", "status": "generated", "url": "https://vault.signatureapi.com/envelopes/55072f0e-b919-4d69-89cd-e7e56af00530/deliverables/del_LXRDwyTeJDVrWXmjwxsAGPq...", //... } ``` You can also list all deliverables for an envelope: ```json theme={null} // GET https://api.signatureapi.com/v1/envelopes/55072f0e-b919-4d69-89cd-e7e56af00530/deliverables // X-API-Key: key_test_... ``` ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard. ## Keep Learning * Learn about [deliverable types](/docs/api/resources/deliverables/object), including standard and simple formats. * Set up [webhooks](/docs/api/guides/how-to/set-up-webhooks) to automate your document processing pipeline. * [Store envelope data](/docs/api/guides/use-cases/store-data-webhook) alongside the signed document for a complete record. * Protect deliverables with a [password](/docs/api/resources/deliverables/password). # Send Signing Links via SMS Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/use-cases/sms-signing-link Deliver signing links through SMS or any custom channel using inline ceremonies with short URLs By default, SignatureAPI sends signing links to recipients via email. If you need to deliver signing links through SMS, WhatsApp, or any other channel, you can disable email delivery and configure an inline ceremony with a short URL directly on the recipient. This example creates an envelope with: * A single PDF document with one signature place. * One recipient with `delivery_type` set to `none` (deliverables are not sent automatically). * An inline `ceremony` object with custom authentication and `url_variant` set to `short` for SMS-friendly URLs. ## Create the Envelope Set `delivery_type` to `none` on the recipient so the completed deliverable is not automatically emailed. Include a `ceremony` object on the recipient with `custom` authentication (since your application handles delivery) and set `url_variant` to `short` to generate a compact URL suitable for SMS. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "documents": [ { "url": "https://example.com/documents/agreement.pdf", "places": [ { "key": "customer_signature", "type": "signature", "recipient_key": "customer" } ] } ], "recipients": [ { "type": "signer", "key": "customer", "name": "Alex Rivera", "email": "alex@example.com", "delivery_type": "none", "ceremony": { "authentication": [ { "type": "custom", "provider": "SMS", "data": { "phone": "+1-555-867-5309" } } ], "url_variant": "short" } } ] } ``` Key properties on the recipient: * `delivery_type`: Set to `none` so the completed deliverable is not automatically emailed to this recipient. Your application is responsible for distributing the deliverable. * `ceremony`: Configures the signing ceremony inline. SignatureAPI creates the ceremony automatically when the envelope starts processing. * `ceremony.authentication`: Uses `custom` type since your application handles delivery. The `provider` and `data` values are recorded in the audit log. * `ceremony.url_variant`: Set to `short` to generate a compact URL like `https://sign.signatureapi.com/s/BgnexxxxxxxxIbRi`, which fits within SMS character limits. The recipient still requires an `email` property even when `delivery_type` is `none`. The email is used for identification and audit purposes. ## Get the Ceremony URL The response includes the short ceremony URL in `recipients[].ceremony.url`: ```json theme={null} // HTTP Status Code 200 { "id": "55072f0e-b919-4d69-89cd-e7e56af00530", "title": "Service Agreement", "recipients": [ { "id": "re_7v7Sion0vqjJioYmwfZ9mf", "key": "customer", "name": "Alex Rivera", "ceremony": { "authentication": [ { "type": "custom", "provider": "SMS", //... } ], "url_variant": "short", "url": "https://sign.signatureapi.com/s/BgnexxxxxxxxIbRi" }, //... } ], //... } ``` ## Send the Link via SMS Take the `url` from the ceremony response and deliver it through your SMS provider (such as Twilio, MessageBird, or Amazon SNS). ```js theme={null} // Example: sending via Twilio const ceremonyUrl = response.recipients[0].ceremony.url; await twilioClient.messages.create({ to: "+15558675309", from: "+15551234567", body: `Please sign your Service Agreement: ${ceremonyUrl}` }); ``` The recipient opens the link on their device, reviews the document, and signs. ## Result When the recipient completes the ceremony, SignatureAPI updates the envelope status as usual. You can track completion through [webhooks](/docs/api/guides/how-to/set-up-webhooks) or by polling the envelope. ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard. ## Keep Learning * Learn more about [short ceremony URLs](/docs/api/resources/ceremonies/ceremony-url#short-ceremony-urls) and when to use them. * Use [custom authentication](/docs/api/guides/how-to/custom-authentication) to record additional context about how the signer was verified. * [Embed the signing ceremony](/docs/api/guides/how-to/embed-web) in your own web application instead of redirecting to the SignatureAPI signing page. * Set up [webhooks](/docs/api/guides/how-to/set-up-webhooks) to receive real-time notifications when signing completes. # Store Envelope Data on Completion Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/guides/use-cases/store-data-webhook Detect envelope completion with webhooks, retrieve captured data, and persist it to your database After an envelope completes, you may want to store the signing data in your own database or system of record. This guide shows how to detect when an envelope completes using a webhook, retrieve the envelope details (including any captured input from the signer), and persist the data. ## Overview The flow works in three steps: 1. SignatureAPI sends an `envelope.completed` webhook event to your endpoint. 2. Your server retrieves the full envelope (including captures) using the API. 3. Your server stores the relevant data in your database. ## Step 1: Set Up a Webhook Endpoint Register a webhook endpoint in the [Dashboard](https://dashboard.signatureapi.com/settings/webhooks) and subscribe to the `envelope.completed` event. See [Set Up Webhooks](/docs/api/guides/how-to/set-up-webhooks) for detailed instructions. ## Step 2: Create an Envelope with Captures When creating the envelope, use `capture_as` on interactive places to store values entered by the signer. Also use `metadata` to attach your own identifiers for matching the envelope back to your records. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Order Confirmation", "metadata": { "order_id": "ORD-2026-1234", "customer_id": "cust_5678" }, "documents": [ { "url": "https://example.com/documents/order-confirmation.pdf", "places": [ { "key": "customer_signature", "type": "signature", "recipient_key": "customer" }, { "key": "reference_number", "type": "text_input", "recipient_key": "customer", "hint": "Your 8-digit reference code", "capture_as": "reference" } ] } ], "recipients": [ { "type": "signer", "key": "customer", "name": "Emily Davis", "email": "emily@example.com" } ] } ``` ## Step 3: Handle the Webhook Event When the envelope completes, SignatureAPI sends an `envelope.completed` event to your endpoint: ```json theme={null} { "id": "evt_4p2oouvNvjp1I9ckgqycH2", "type": "envelope.completed", "timestamp": "2026-03-04T15:00:01.999Z", "data": { "object_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "object_type": "envelope", "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "envelope_metadata": { "order_id": "ORD-2026-1234", "customer_id": "cust_5678" } } } ``` The `envelope_metadata` property reflects the metadata you attached when creating the envelope. You can use these values to match the event to your internal records without making an additional API call. ## Step 4: Retrieve the Envelope If you need data beyond what the webhook event provides (such as captured input from the signer), use the `envelope_id` from the event to fetch the full envelope. ```json theme={null} // GET https://api.signatureapi.com/v1/envelopes/55072f0e-b919-4d69-89cd-e7e56af00530 // X-API-Key: key_test_... ``` ```json theme={null} // HTTP Status Code 200 { "id": "55072f0e-b919-4d69-89cd-e7e56af00530", "title": "Order Confirmation", "status": "completed", "metadata": { "order_id": "ORD-2026-1234", "customer_id": "cust_5678" }, "captures": { "reference": "11223344" }, //... } ``` The `captures` object contains any values the signer entered in interactive places that had `capture_as` defined. ## Step 5: Store the Data With the envelope details and captures in hand, persist the data to your database. Here is a conceptual example: ```js theme={null} app.post("/webhooks/signatureapi", async (req, res) => { const event = req.body; if (event.type === "envelope.completed") { // Fetch the full envelope to get captures const envelope = await fetch( `https://api.signatureapi.com/v1/envelopes/${event.data.envelope_id}`, { headers: { "X-API-Key": process.env.SIGNATUREAPI_KEY } } ).then(r => r.json()); // Store in your database await db.signingRecords.create({ envelope_id: envelope.id, order_id: envelope.metadata.order_id, customer_id: envelope.metadata.customer_id, reference: envelope.captures.reference, completed_at: event.timestamp }); } res.status(200).send("OK"); }); ``` Always [verify the webhook signature](/docs/api/guides/how-to/set-up-webhooks#verify-the-signature) before processing events in production. ## Try It [Try this example in Postman](/docs/api/postman) using your [test API key](/docs/api/test-mode) to create a free, non-binding test envelope. Test envelopes won't send emails, but you can review them in your dashboard. ## Keep Learning * Learn more about [captures](/docs/api/resources/envelopes/captures) and which place types support them. * Set up [webhooks](/docs/api/guides/how-to/set-up-webhooks) with signature verification and retry handling. * Use [topics](/docs/api/resources/envelopes/topics) to route events from specific envelopes to different webhook endpoints. * [Download signed documents](/docs/api/guides/use-cases/save-signed-documents) after the envelope completes. # SignatureAPI OpenAPI Spec Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/openapi Access the SignatureAPI OpenAPI v3.1 specification and Arazzo workflow definitions We are currently working on the description of our API following the [OpenAPI v3.1 specification](https://spec.openapis.org/oas/v3.1.0.html). If you're interested in previewing it, please [contact us](https://signatureapi.com/contact-us). We are also developing an [Arazzo](https://www.openapis.org/arazzo) spec for our most common workflows. Let us know if you're interested in learning more. # API Overview Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/overview Understand SignatureAPI's RESTful architecture, base URLs, HTTP methods, versioning, and response codes SignatureAPI API is organized around REST. Our API has predictable resource-oriented URLs, accepts JSON-encoded request bodies, returns JSON-encoded responses, and uses standard HTTP response codes and methods. ### Base URL The base URL is `https://api.signatureapi.com` for both [test and live modes](/docs/api/test-mode). For example, to create an envelope, you do a `POST` request to `https://api.signatureapi.com/v1/envelopes`. ### HTTP Semantics We use HTTP methods GET, POST, DELETE as defined in RFC 9110, and PATCH as defined in RFC 5789. We use the following HTTP Status codes for successful responses: | Status Code | Description | | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | | `200 OK` | Request succeeded for a GET, POST, or PATCH call. | | `201 Created` | Request succeeded for a POST request that created a new resource. The response includes a Location header pointing to the newly created resource. | ### Versioning The current version of the API is **v1**. We will increment the version number if we make a change that breaks backward compatibility. These are not breaking changes: * Any additive change, such as adding endpoints, optional arguments, or enum values. * Making a required request parameter optional. * Making a validation less restrictive. * Changes to error responses. * Changes to the order of fields returned in a response. * Changes to the length or format of opaque strings, such as object IDs, error messages, and other human-readable strings. * Adding new event types. # Pagination Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/pagination Navigate paginated API responses using cursor-based pagination with next and previous links All endpoints that list objects provide support for pagination. Paginated responses return items in reverse chronological order, such that the most recently created object will be returned first on the list and the oldest will be returned last. The result includes a `links` object with a `previous` and a `next` property. Do a `GET` to the URLs in those properties to fetch the previous or next page of results. ### Attributes Paginated responses share a common structure using cursor-based pagination. Links to fetch the next and previous page of the paginated result. Treat these URLs as a opaque strings. Do not try to parse or construct it. A pre-built absolute path URI for fetching the next page of results. If the value is `null`, this is the last page of results. A pre-built absolute path URI for fetching the previous page of results. If the value is `null`, this is the first page of results. An array of objects, sorted in reverse chronological order by creation date. ### Example ```json theme={null} { "links": { "next": "https://api.signatureapi.com/v1/envelopes/?cursor=seq_0thJdKRhN4&limit=20", "previous": "https://api.signatureapi.com/v1/envelopes/?cursor=seq_7yNl3c0t&limit=20" }, "data": [ {...}, {...}, ... ] } ``` # API Playground Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/playground Explore our API effortlessly using the API Playground, directly accessible in your Dashboard. Your [test API key](/docs/api/test-mode) comes preconfigured, allowing you to start experimenting within seconds of [creating your free account](https://accounts.signatureapi.com/sign-up). With the API Playground, you can create envelopes, monitor the generated resources, and review the emails that are sent, all in real time.
SignatureAPI API Playground
# SignatureAPI in Postman Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/postman Test SignatureAPI endpoints and explore code examples with our public Postman collection We publish a Postman Collection that you can use to test our API and generate envelopes with many of our features. This Postman collection showcases how to create envelopes and initiate the electronic signature process using SignatureAPI. This collection is frequently updated and currently includes the following examples: * **Place Positioning** * Create an envelope with placeholders * Create an envelope with fixed positions * **Document Templates** * Create an envelope with a docx template * **Languages** * Create an envelope with Spanish interface * **Timestamp formats** * Create an envelope with month-day-year format * Create an envelope with day/month/year format * **Timezones** * Create an envelope in UTC timezone * Create an envelope in Hong Kong timezone * **Temporary Upload** * Create an envelope with a temporary upload * **Embedded Ceremony** * Create an envelope and a recipient's ceremony * **Multiple Recipients** * Create an envelope with multiple recipients signing in parallel * Create an envelope with multiple recipients signing sequentially # Quickstart Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/quickstart Create your first envelope and send documents for signature in minutes with the SignatureAPI # Rate Limiting Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/rate-limiting Understand API rate limits and how to handle throttled requests SignatureAPI enforces rate limits to ensure fair usage and platform stability. Rate limits are applied per API key. There are two components to rate limiting: * **Rate** is the sustained number of requests allowed per second. * **Burst** is the maximum number of requests that can be sent in a short spike before throttling kicks in. Once the burst is exhausted, requests are throttled to the sustained rate. ## Default limits | Metric | Limit | | ------ | ------------------ | | Rate | 10 requests/second | | Burst | 10 requests | ## Extended limits For higher-volume workloads, the extended plan increases both limits: | Metric | Limit | | ------ | --------------------- | | Rate | 1,000 requests/second | | Burst | 1,000 requests | To upgrade to extended limits, contact [support](https://signatureapi.com/support). ## Rate limit responses When you exceed the rate limit, the API returns a `429 Too Many Requests` response. ```json theme={null} // HTTP Status Code 429 { "type": "https://signatureapi.com/docs/v1/errors/too-many-requests", "title": "Too many requests", "status": 429, "detail": "The client is sending too many requests per second." } ``` ## Handling rate limits When you receive a `429` response, wait briefly before retrying. A simple approach: 1. Wait 1 second after receiving a `429` response. 2. Retry the request. 3. If you receive another `429`, double the wait time (2 seconds, then 4 seconds, and so on). 4. After 5 retries, stop and log the failure for investigation. # Custom Authentication Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/ceremonies/authentication/custom Use your own authentication system to verify recipients before they access the signing ceremony. With custom authentication, your application or workflow authenticates the [recipient](/docs/api/resources/recipients/object). SignatureAPI provides a ceremony URL that you share directly with the recipient to start their signing session. ## When to use Custom authentication is the right choice when: * Recipients are already authenticated in your system. * You want to integrate signing into your existing application flow. * You need specific authentication methods (biometrics, SSO, multi-factor). * You want to embed the ceremony in your application. After creating the ceremony, you can: * Send the URL via email or SMS with your own branding. * Redirect the recipient directly to the ceremony. * Embed the ceremony in your application interface. * Include the URL in push notifications. ## Creating a custom authentication ceremony ### On envelope creation (automatic) Set the recipient's ceremony authentication to `custom` when creating the envelope. Include your authentication details in the `provider` and `data` properties. ```json Custom authentication ceremony on envelope creation theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "recipients": [ { "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com", "ceremony": { "authentication": [ { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3", "Authenticated At": "2025-12-31T23:59:59Z" } } ] } } ], "documents": [ /* ... */ ] } ``` The response includes `ceremony.url` for each recipient: ```json Response (excerpt) theme={null} { "id": "abcdef12-3456-7890-1234-abcdef123456", "title": "Service Agreement", "recipients": [ { "type": "signer", "key": "client", "ceremony": { "authentication": [ { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3", "Authenticated At": "2025-12-31T23:59:59Z" } } ], "url": "https://sign.signatureapi.com/en/start?token=eyJhbGcNiIsInR..." } } ] } ``` ### Create Ceremony endpoint (manual) Use the [Create Ceremony](/docs/api/resources/ceremonies/create) endpoint to create a custom authentication ceremony after the envelope is created. Creating a new ceremony automatically revokes any previous ceremony for that recipient. Only the most recent ceremony remains active. ```json Create custom authentication ceremony theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3", "Authenticated At": "2025-12-31T23:59:59Z" } } ] } ``` The `url` property in the response is the ceremony URL to deliver to the recipient. ```json Response theme={null} // HTTP Status Code 201 { "authentication": [ { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3", "Authenticated At": "2025-12-31T23:59:59Z" } } ], "embeddable_in": [], "redirect_url": null, "redirect_delay": 3, "url_variant": "standard", "url": "https://sign.signatureapi.com/en/start?token=eyJhbGcNiIsInR..." } ``` ## Authentication provider Set `provider` to the name of the company or application that authenticated the recipient. This value appears in the audit log: > John Doe has been authenticated by \[Provider Name] ## Authentication data The `data` property holds key-value pairs that link the ceremony to your authentication records. These values appear in the envelope audit log. The values in `data` must be sufficient to verify how the recipient was authenticated. In edge cases such as legal proceedings, you may need to provide your internal records to confirm the recipient's identity. When using custom authentication, retain all records necessary to prove authentication. Review our [Terms & Conditions](https://signatureapi.com/terms) for details. Useful data to include: * **Session data:** Session IDs and session start timestamps that link to your authentication records. * **User identification:** Email addresses, phone numbers, or user IDs from your system. * **Authentication method:** The method used (OTP, biometrics, SSO) and relevant details like device IDs or IP addresses. * **Transaction references:** Hashes, nonces, or other unique identifiers. Example with rich authentication data: ```json theme={null} { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3", "Order Reference": "25005", "Authentication Timestamp": "2025-12-31T10:00:00Z", "Authentication Method": "SMS", "Phone Number": "+1-111-1111111", "IP Address": "100.100.100.100" } } ``` Review the values in `data` carefully. Do not include unnecessary sensitive information. ## Using the ceremony URL After creating the ceremony, you receive the URL. You can: * Send a customized email using your own domain and branding. * Embed the ceremony in your application. * Redirect the recipient from your application directly to the ceremony. Treat ceremony URLs as sensitive credentials. Do not expose them in public forums or share them with unauthorized users. ## Audit log When a recipient accesses a ceremony using custom authentication, SignatureAPI records the timestamp, provider, and authentication data. The audit log entry looks like this:
12/31/2025 11:59:59 PM
John Doe (#7161cf07) has been authenticated by SuperApp:
Session ID: a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3
Order Reference: 25005
Authenticated At: Dec 31, 2025 23:59:59
Authentication Method: SMS
Phone Number: +1-111-1111111
IP Address: 100.100.100.100
As provided by the initiator of the electronic signature transaction.
# Email Code Authentication Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/ceremonies/authentication/email-code Authenticate recipients with a verification code sent to their email address. With email code authentication, SignatureAPI sends the [recipient](/docs/api/resources/recipients/object) an email containing a 9-digit verification code. The recipient enters this code to authenticate and access their signing ceremony. ## When to use Email code authentication is useful when: * You want to share the ceremony URL through your own channels (SMS, app notifications, direct links). * Recipients are in environments where email links may be blocked by security policies. * You want to embed the ceremony in your application while still using email-based authentication. Unlike [email link authentication](/docs/api/resources/ceremonies/authentication/email-link), the ceremony URL is returned in the API response. You deliver the URL yourself. ## How it works Create an envelope or call the Create Ceremony endpoint with `email_code` authentication. The API returns the ceremony URL. Share the ceremony URL with the recipient through your chosen channel (email, SMS, in-app link, etc.). When the recipient opens the URL, SignatureAPI prompts them to verify their email. After they click the verification button, SignatureAPI sends them a 9-digit code by email. The recipient enters the code. Once verified, they can proceed with signing. ## Creating an email code ceremony ### On envelope creation (automatic) Set the recipient's ceremony authentication to `email_code` when creating the envelope. The ceremony URL is returned in the response. ```json Email code ceremony on envelope creation theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "recipients": [ { "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com", "ceremony": { "authentication": [ { "type": "email_code" } ] } } ], "documents": [ /* ... */ ] } ``` The response includes `ceremony.url` for each recipient: ```json Response (excerpt) theme={null} { "id": "abcdef12-3456-7890-1234-abcdef123456", "title": "Service Agreement", "recipients": [ { "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com", "ceremony": { "authentication": [ { "type": "email_code" } ], "url": "https://sign.signatureapi.com/en/start?token=eyJhbGcNiIsInR..." } } ] } ``` ### Create Ceremony endpoint (manual) Use the [Create Ceremony](/docs/api/resources/ceremonies/create) endpoint to create an email code ceremony after the envelope is created. Creating a new ceremony automatically revokes any previous ceremony for that recipient. Only the most recent ceremony remains active. ```json Create email code ceremony theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "email_code" } ] } ``` The `url` property in the response is the ceremony URL to deliver to the recipient. ```json Response theme={null} // HTTP Status Code 201 { "authentication": [ { "type": "email_code" } ], "embeddable_in": [], "redirect_url": null, "redirect_delay": 3, "url_variant": "standard", "url": "https://sign.signatureapi.com/en/start?token=eyJhbGcNiIsInR..." } ``` ## Recipient experience The recipient opens the ceremony URL and is asked to verify their email address. Email verification prompt After the recipient clicks to verify, SignatureAPI sends them an email with the 9-digit code. Email with code In test mode, no emails are sent. You can view the verification codes that would have been sent in the SignatureAPI dashboard under ceremony details. The recipient enters the code in the ceremony interface. Code entry interface After the correct code is entered, the recipient can proceed with signing. Successful verification ## Audit log When the recipient enters the verification code, SignatureAPI records the timestamp. The audit log entry looks like this:
12/31/2025 11:59:59 PM
John Doe (#7161cf07) has authenticated using a verification code sent to john⁠@example.com.
# Email Link Authentication Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/ceremonies/authentication/email-link Authenticate recipients with a secure link sent to their email address. With email link authentication, SignatureAPI sends the [recipient](/docs/api/resources/recipients/object) an email with a direct link. Clicking the link authenticates the recipient and opens their signing session. This is the default authentication method. If you don't specify a ceremony configuration, SignatureAPI uses email link authentication automatically. ## When to use Email link authentication works well when: * You want the simplest experience for recipients. * Recipients check email to access documents. * You don't need to control the ceremony URL or deliver it through other channels. * Your security requirements allow email-based authentication. ## Creating an email link ceremony You can create an email link ceremony automatically when creating an envelope, or manually using the Create Ceremony endpoint. ### On envelope creation (automatic) By default, SignatureAPI creates an email link ceremony and sends the invitation email when you create an envelope. ```json Default email link ceremony theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "recipients": [ { "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com" } ], "documents": [ /* ... */ ] } ``` To add ceremony options such as a redirect URL, set the `ceremony` property explicitly. ```json Email link ceremony with redirect URL theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "recipients": [ { "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com", "ceremony": { "authentication": [ { "type": "email_link" } ], "redirect_url": "https://www.example.com/redirect" } } ], "documents": [ /* ... */ ] } ``` ### Create Ceremony endpoint (manual) Use the [Create Ceremony](/docs/api/resources/ceremonies/create) endpoint to create an email link ceremony after the envelope is created. Creating a new ceremony automatically revokes any previous ceremony for that recipient. Only the most recent ceremony remains active. ```json Create email link ceremony theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "email_link" } ] } ``` ## Email customization By default, SignatureAPI derives the email content from the envelope: * Subject: `envelope.title` * Message body: `envelope.message` * Language: `envelope.language` For example, an envelope with: ```json theme={null} { "title": "Dummy Agreement", "message": "Please take a moment to review the attached agreement. Once you complete your electronic signature, a signed copy will be sent to your email.\n\nIf you have questions, feel free to reach out." } ``` produces an email similar to this: ### Per-recipient overrides Use `subject_override` and `message_override` on the `email_link` authentication object to customize the email for a specific recipient. ```json Per-recipient email customization theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "recipients": [ { "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com", "ceremony": { "authentication": [ { "type": "email_link", "subject_override": "Action Required: Please sign the Service Agreement", "message_override": "Dear John,\n\nPlease review and sign the attached Service Agreement at your earliest convenience." } ] } } ], "documents": [ /* ... */ ] } ``` `message_override` supports Markdown formatting: `**bold**`, `*italic*`, and `\n\n` for paragraph breaks. To send invitation emails through your own infrastructure with custom branding, use [Custom Authentication](/docs/api/resources/ceremonies/authentication/custom) to obtain the ceremony URL and deliver it yourself. ## Audit log When a recipient clicks the email link, SignatureAPI records the timestamp. The audit log entry looks like this:
12/31/2025 11:59:59 PM
John Doe (#7161cf07) has authenticated using a secure link sent to john⁠@example.com.
# Multiple Authentication Methods Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/ceremonies/authentication/multiple Combine authentication methods to require recipients to complete more than one verification step. You can combine multiple authentication methods in a single ceremony. Recipients must complete each method in sequence before accessing the ceremony. ## Rules Not all combinations are valid. The table below shows which methods can appear at each position. | Method | First step | Second step and beyond | | ---------------------------------------------------------------------- | :--------: | :--------------------: | | [Email Link](/docs/api/resources/ceremonies/authentication/email-link) | Yes | No | | [Email Code](/docs/api/resources/ceremonies/authentication/email-code) | Yes | Yes | | [Custom](/docs/api/resources/ceremonies/authentication/custom) | Yes | No | Additional constraints: * A ceremony supports a maximum of 5 authentication methods. * `email_link` and `custom` can each only be used as the first step. * `email_link` and `custom` cannot be combined together. * You cannot use the same authentication method more than once in a ceremony. ## Common combinations ### Custom + Email Code Your application authenticates the recipient first. SignatureAPI then independently verifies the recipient's identity by sending a code to their email. Use this combination when you want to authenticate recipients in your own system and also require a second factor that SignatureAPI controls. ```json theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3", "Authenticated At": "2026-01-15T10:30:00Z" } }, { "type": "email_code" } ] } ``` Recipient experience: The recipient authenticates in your system (custom authentication). You direct the recipient to the ceremony URL or embed the ceremony in your app. SignatureAPI prompts for additional email verification. The recipient enters the 9-digit code from their email. The recipient proceeds to sign documents. ### Email Link + Email Code SignatureAPI sends the invitation email automatically. When the recipient opens the ceremony, they must also enter an email verification code. Use this combination when you want SignatureAPI to handle delivery but also need a second verification step inside the ceremony, for example to meet compliance requirements. ```json theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "email_link" }, { "type": "email_code" } ] } ``` Recipient experience: The recipient clicks the ceremony link in the email sent by SignatureAPI. SignatureAPI prompts for a second verification step. The recipient enters the 9-digit code from their email. The recipient proceeds to sign documents. # Recipient Authentication Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/ceremonies/authentication/overview Choose how recipients verify their identity before accessing a signing ceremony. Before a recipient can access a [ceremony](/docs/api/resources/ceremonies/object), they must authenticate. SignatureAPI supports three authentication methods that you can use individually or combine for added security. ## Authentication methods ### Email Link (default) SignatureAPI sends the recipient an email with a direct link. Clicking the link authenticates the recipient automatically. * No setup required. Works out of the box. * Simplest experience for recipients. * Ceremonies are created and emails sent automatically when you create an envelope. [Learn more about Email Link Authentication](/docs/api/resources/ceremonies/authentication/email-link) ### Email Code SignatureAPI sends the recipient an email with a 9-digit verification code. The recipient enters the code to authenticate. * You receive the ceremony URL to share through your own channels. * Confirms the recipient has access to their email account. * Supports SMS, app notifications, or direct links as delivery channels. [Learn more about Email Code Authentication](/docs/api/resources/ceremonies/authentication/email-code) ### Custom Your application authenticates the recipient. SignatureAPI provides a ceremony URL that you share directly or embed in your application. * Use your existing authentication systems. * Supports embedded signing experiences. * Your authentication details are recorded in the audit log. [Learn more about Custom Authentication](/docs/api/resources/ceremonies/authentication/custom) ### Multiple methods Combine authentication methods for enhanced security. Recipients complete each method in sequence before accessing the ceremony. [Learn more about Multiple Authentication Methods](/docs/api/resources/ceremonies/authentication/multiple) ## How to create a ceremony You can create a ceremony in two ways: automatically when creating an envelope, or manually using the Create Ceremony endpoint. ### On envelope creation (automatic) Pass a `ceremony` object on each recipient when creating an envelope. SignatureAPI creates the ceremony immediately. If you omit `ceremony`, SignatureAPI uses email link authentication by default. ```json Email Link (Default) theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "recipients": [ { "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com" } ], "documents": [ /* ... */ ] } ``` ```json Email Code theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "recipients": [ { "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com", "ceremony": { "authentication": [ { "type": "email_code" } ] } } ], "documents": [ /* ... */ ] } ``` ```json Custom theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "recipients": [ { "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com", "ceremony": { "authentication": [ { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3", "Logged In At": "2026-12-31T23:59:59Z" } } ] } } ], "documents": [ /* ... */ ] } ``` ```json Multiple theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "recipients": [ { "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com", "ceremony": { "authentication": [ { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3", "Logged In At": "2026-12-31T23:59:59Z" } }, { "type": "email_code" } ] } } ], "documents": [ /* ... */ ] } ``` ### Create Ceremony endpoint (manual) Use the [Create Ceremony](/docs/api/resources/ceremonies/create) endpoint after the envelope is created. This lets you change authentication methods or create new access for the same recipient. Creating a new ceremony automatically revokes any previous ceremony for that recipient. Only the most recent ceremony remains active. Common use cases: * Switch from custom authentication to email link if the recipient hasn't signed within a set time. * Provide a new URL after the original one expires. * Update ceremony settings like the redirect URL. ```json Email Link theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "email_link" } ] } ``` ```json Email Code theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "email_code" } ] } ``` ```json Custom theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3", "Logged In At": "2026-12-31T23:59:59Z" } } ] } ``` ```json Multiple theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3", "Logged In At": "2026-12-31T23:59:59Z" } }, { "type": "email_code" } ] } ``` # Ceremony URL Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/ceremonies/ceremony-url Learn how to obtain the ceremony URL to deliver signing access yourself or embed the ceremony in your application. Recipients use the ceremony URL to access their signing ceremony and complete their actions. By default, SignatureAPI creates a ceremony for each recipient when you create an envelope. It uses email link authentication and sends the recipient an email with their ceremony link. You don't need to handle URL delivery in that case. You may want to obtain the ceremony URL directly to: * [Embed](/docs/embedded/introduction) the signing ceremony in your web or mobile application * Redirect users to the ceremony from within your application workflow * Send the invitation through your own email infrastructure with custom branding ## When ceremony URLs are available A ceremony URL is available when the ceremony is active and not yet completed. If the first authentication method is `email_link`, SignatureAPI delivers the URL by email. The `url` property will be `null` in that case. When SignatureAPI sends the URL directly to the recipient (as with [Email Link Authentication](/docs/api/resources/ceremonies/authentication/email-link)), the `url` property is `null`. You don't need to handle delivery yourself. ## How to get a ceremony URL Set the ceremony's authentication method to one of the following: * [Email Code](/docs/api/resources/ceremonies/authentication/email-code) * [Custom Authentication](/docs/api/resources/ceremonies/authentication/custom) * [Multiple Authentication](/docs/api/resources/ceremonies/authentication/multiple) with Email Code or Custom Authentication as the first step The URL is returned in the `url` property of the ceremony object. You can retrieve it in several ways. ### From envelope operations When you create or retrieve an envelope, the ceremony URL is available in the `url` property of each recipient's ceremony object. ```json Envelope object theme={null} { "id": "abcdef12-3456-7890-1234-abcdef123456", "title": "Service Agreement", "recipients": [ { "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com", "ceremony": { "authentication": [ { "type": "email_code" } ], "url": "https://sign.signatureapi.com/en/start?token=eyJhbGciOiJFUzI1NiIsInR...", //... } //... } ] //... } ``` ### From recipient operations When you retrieve a recipient, the ceremony URL is available in the `url` property of the recipient's ceremony object. ```json Recipient object theme={null} { "type": "signer", "key": "client", "name": "John Doe", "email": "john.doe@example.com", "ceremony": { "authentication": [ { "type": "email_code" } ], "url": "https://sign.signatureapi.com/en/start?token=eyJhbGciOiJFUzI1NiIsInR...", //... } //... } ``` ### From ceremony operations When you create a ceremony using the [Create Ceremony](/docs/api/resources/ceremonies/create) endpoint, the URL is returned in the `url` property of the ceremony object. ```json Ceremony object theme={null} { "authentication": [ { "type": "email_code" } ], "url": "https://sign.signatureapi.com/en/start?token=eyJhbGciOiJFUzI1NiIsInR...", //... } ``` ## Short ceremony URLs Standard ceremony URLs are long. They may not fit in space-constrained channels like SMS or push notifications. Set `url_variant` to `short` when creating the ceremony to generate a shorter URL. ```json Request theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3", "Authenticated At": "2025-12-31T23:59:59Z" } } ], "url_variant": "short" } ``` ```json Response theme={null} // HTTP Status Code 201 { //... "url": "https://sign.signatureapi.com/s/BgnexxxxxxxxIbRi" } ``` ## URL expiration Ceremony URLs expire 30 days after creation, or when a new ceremony is created for the same recipient. Contact support to adjust the expiration period. How to get a new URL depends on the authentication method and URL variant: | Authentication | Standard URL | Short URL | | ---------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | -------------------------------------------------------- | | [Email Link](/docs/api/resources/ceremonies/authentication/email-link) | [Resend](/docs/api/resources/recipients/resend) or [Create Ceremony](/docs/api/resources/ceremonies/create) | [Create Ceremony](/docs/api/resources/ceremonies/create) | | [Email Code](/docs/api/resources/ceremonies/authentication/email-code) | [Get Envelope](/docs/api/resources/envelopes/get) | [Create Ceremony](/docs/api/resources/ceremonies/create) | | [Custom](/docs/api/resources/ceremonies/authentication/custom) | [Get Envelope](/docs/api/resources/envelopes/get) | [Create Ceremony](/docs/api/resources/ceremonies/create) | Short URLs do not refresh automatically. Create a new ceremony to generate a new short URL. ## Invalid or expired links Recipients may see an "Invalid link" error when accessing a ceremony URL. Common causes: * **The URL expired.** Ceremony URLs expire 30 days after creation. Create a new ceremony to generate a fresh URL. * **A newer ceremony replaced it.** Creating a new ceremony for the same recipient invalidates the previous URL. Only the most recent ceremony URL is active. * **The envelope was canceled or completed.** Ceremony URLs stop working after the envelope reaches a terminal status. * **The URL was modified.** The full URL, including the token, must be used exactly as returned by the API. Truncated or modified URLs will not work. If a recipient reports an invalid link, check the envelope and recipient status first. If the envelope is still in progress, [create a new ceremony](/docs/api/resources/ceremonies/create) to generate a new URL. # Create a ceremony Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/ceremonies/create POST /v1/recipients/{recipient_id}/ceremonies Create a new signing ceremony for a recipient with custom authentication options. Creates a new [ceremony](/docs/api/resources/ceremonies/object) for a [recipient](/docs/api/resources/recipients/object). Any previous active ceremony for the recipient is automatically revoked. The `authentication` array specifies which authentication methods the recipient must complete to access the ceremony. You can configure multiple methods. Recipients complete them in sequence. Learn more in [Recipient Authentication](/docs/api/resources/ceremonies/authentication/overview). ## Path Parameters The unique identifier of the recipient. Recipient IDs use the `re_` prefix. ## Body Parameters
With **email link authentication**, the recipient receives an email with a direct link to the ceremony. Clicking the link authenticates the recipient and opens the signing session.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email link authentication, set `type` to `email_link`. A custom subject line for the invitation email sent to this recipient. When not set, the subject defaults to the [envelope title](/docs/api/resources/envelopes/object#param-title). Maximum 500 characters. A custom message body for the invitation email sent to this recipient. When not set, the message defaults to the [envelope message](/docs/api/resources/envelopes/object#param-message). Supports Markdown formatting: `**bold**`, `*italic*`, and `\n\n` for paragraph breaks. Maximum 2000 characters.
With **email code authentication**, the recipient receives an email from SignatureAPI containing a 9-digit code. The recipient must enter this code to authenticate and access the ceremony.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email code authentication, set `type` to `email_code`.
With **custom authentication**, your application authenticates the recipient. SignatureAPI provides a ceremony URL that you share or embed in your application to give the recipient access.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For custom authentication, set `type` to `custom`. The name of your company or application that authenticated the recipient. This value appears in the envelope audit log as the authentication provider. Key-value pairs with metadata about the authentication event, such as timestamps, session IDs, and user identifiers. These values appear in the envelope audit log. The values in `data` must be sufficient to verify how the recipient was authenticated. You must retain all records needed to prove the recipient's authentication, such as session information. In cases such as legal proceedings, you may need to provide these records to confirm identity. Review our [Terms & Conditions](https://signatureapi.com/terms) for details.
An HTTPS URL to redirect the recipient to after the ceremony finishes. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The delay in seconds before the ceremony redirects to `redirect_url` (standalone ceremonies) or emits completion events (embedded ceremonies). Defaults to `3`. Allowed range: `0` to `20`. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The format of the ceremony URL. Available options: * `standard` (default): Full-length URL. Works for most use cases. * `short`: Shortened URL. Use this when sharing through space-constrained channels such as SMS or push notifications. Origins allowed to embed this ceremony in an iframe. These values set the `frame-ancestors` directive in the ceremony's Content Security Policy (CSP) header. Sources typically take the form of a scheme and host (for example, `https://app.example.com`). Wildcards are supported (for example, `https://*.example.com`). For all available options, see the [frame-ancestors documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors#sources). Defaults to an empty list (`[]`), which means embedding is not allowed. To allow embedding from all origins (not recommended for production), use `["*"]`. Only the origin (scheme and host) is used. Paths are ignored. ## Returns Returns a `201 Created` status code with [a ceremony object](/docs/api/resources/ceremonies/object) on success, or an [error](/docs/api/errors) otherwise. ```json Email Link theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "email_link", "subject_override": "Please sign the Service Agreement", "message_override": "Please review and sign the attached agreement." } ] } ``` ```json Email Code theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "email_code" } ] } ``` ```json Custom Auth theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "se_88620999344", "Authenticated At": "2025-12-31T23:59:59Z" } } ], "embeddable_in": [ "https://superapp.example.com" ] } ``` ```json With Redirect URL theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "email_link" } ], "redirect_url": "https://example.com/signing-complete", "redirect_delay": 5 } ``` ```json Embeddable theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ { "type": "custom", "provider": "MyApp", "data": { "user_id": "usr_12345" } } ], "embeddable_in": [ "https://app.example.com", "https://staging.example.com" ], "redirect_url": "https://app.example.com/done" } ``` ```json Email Link theme={null} // HTTP Status Code 201 { "authentication": [ { "type": "email_link", "subject_override": "Please sign the Service Agreement", "message_override": "Please review and sign the attached agreement." } ], "embeddable_in": [], "redirect_url": null, "redirect_delay": 3, "url_variant": "standard", "url": null } ``` ```json Email Code theme={null} // HTTP Status Code 201 { "authentication": [ { "type": "email_code" } ], "embeddable_in": [], "redirect_url": null, "redirect_delay": 3, "url_variant": "standard", "url": "https://sign.signatureapi.com/en/start?token=eyJhbGciOiJFUzI1NiIsInR..." } ``` ```json Custom Auth theme={null} // HTTP Status Code 201 { "authentication": [ { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "se_88620999344", "Authenticated At": "2025-12-31T23:59:59Z" } } ], "embeddable_in": [ "https://superapp.example.com" ], "redirect_url": null, "redirect_delay": 3, "url_variant": "standard", "url": "https://sign.signatureapi.com/en/start?token=eyJhbGciOiJFUzI1NiIsInR..." } ``` ```json With Redirect URL theme={null} // HTTP Status Code 201 { "authentication": [ { "type": "email_link" } ], "embeddable_in": [], "redirect_url": "https://example.com/signing-complete", "redirect_delay": 5, "url_variant": "standard", "url": null } ``` ```json Embeddable theme={null} // HTTP Status Code 201 { "authentication": [ { "type": "custom", "provider": "MyApp", "data": { "user_id": "usr_12345" } } ], "embeddable_in": [ "https://app.example.com", "https://staging.example.com" ], "redirect_url": "https://app.example.com/done", "redirect_delay": 3, "url_variant": "standard", "url": "https://sign.signatureapi.com/en/start?token=eyJhbGciOiJFUzI1NiIsInR..." } ``` # Ceremony Lifecycle Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/ceremonies/lifecycle The lifecycle and statuses of a ceremony. A ceremony's `status` tracks the recipient's progress through their signing session. | Status | Description | | ----------- | ------------------------------------------------------------------------- | | `pending` | The ceremony was created but the envelope is not yet active. | | `active` | The ceremony is ready for the recipient to access. | | `completed` | The recipient finished their actions. | | `declined` | The recipient declined to act. | | `revoked` | The ceremony was replaced by a new ceremony or the envelope was canceled. | # Ceremony Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/ceremonies/object The ceremony object represents a signing session where a recipient interacts with an envelope. A ceremony is the session where a recipient authenticates and acts on an envelope. Depending on the recipient type, those actions include signing, approving, or preparing documents. Each recipient has one active ceremony at a time. Creating a new ceremony for a recipient automatically revokes any previous ceremony. A ceremony belongs to a [recipient](/docs/api/resources/recipients/object). ## Lifecycle A ceremony's `status` tracks the recipient's progress. See the [ceremony lifecycle](/docs/api/resources/ceremonies/lifecycle) for details on each status. ## Attributes
With **email link authentication**, the recipient receives an email with a direct link to the ceremony. Clicking the link authenticates the recipient and opens the signing session.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email link authentication, this value is `email_link`. The custom subject line used for this recipient's invitation email. `null` if the envelope title is used. The custom message body used for this recipient's invitation email. `null` if the envelope message is used.
With **email code authentication**, the recipient receives an email from SignatureAPI containing a 9-digit code. The recipient must enter this code to authenticate and access the ceremony.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email code authentication, this value is `email_code`.
With **custom authentication**, your application authenticates the recipient. SignatureAPI provides a ceremony URL that you share or embed in your application to give the recipient access.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For custom authentication, this value is `custom`. The name of your company or application that authenticated the recipient. This value appears in the envelope audit log as the authentication provider. Key-value pairs with metadata about the authentication event, such as timestamps, session IDs, and user identifiers. These values appear in the envelope audit log. The values in `data` must be sufficient to verify how the recipient was authenticated. You must retain all records needed to prove the recipient's authentication, such as session information. In cases such as legal proceedings, you may need to provide these records to confirm identity. Review our [Terms & Conditions](https://signatureapi.com/terms) for details.
An HTTPS URL to redirect the recipient to after the ceremony finishes. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The delay in seconds before the ceremony redirects to `redirect_url` (standalone ceremonies) or emits completion events (embedded ceremonies). Defaults to `3`. Allowed range: `0` to `20`. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The format of the ceremony URL. Available options: * `standard` (default): Full-length URL. Works for most use cases. * `short`: Shortened URL. Use this when sharing through space-constrained channels such as SMS or push notifications. Origins allowed to embed this ceremony in an iframe. These values set the `frame-ancestors` directive in the ceremony's Content Security Policy (CSP) header. Sources typically take the form of a scheme and host (for example, `https://app.example.com`). Wildcards are supported (for example, `https://*.example.com`). For all available options, see the [frame-ancestors documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors#sources). Defaults to an empty list (`[]`), which means embedding is not allowed. To allow embedding from all origins (not recommended for production), use `["*"]`. Only the origin (scheme and host) is used. Paths are ignored. The URL where the recipient can access the ceremony. You can share this link with the recipient directly or embed it in your application. This property is `null` when: * The ceremony uses `email_link` authentication. SignatureAPI delivers the URL by email in that case. * The ceremony is not active (for example, it is completed, revoked, or declined). The URL expires 30 days after creation, or when a new ceremony is created for the same recipient. ```json Email Link theme={null} { "authentication": [ { "type": "email_link", "subject_override": null, "message_override": null } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": null } ``` ```json Email Code theme={null} { "authentication": [ { "type": "email_code" } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": "https://sign.signatureapi.com/en/start?token=eyJhbGciOiJFUzI1NiIsInR..." } ``` ```json Custom Auth theme={null} { "authentication": [ { "type": "custom", "provider": "SuperApp", "data": { "Session ID": "se_88620999344", "Authenticated At": "Dec 31, 2025 23:59:59" } } ], "redirect_url": "https://www.example.com/redirect", "redirect_delay": 5, "embeddable_in": [ "https://app.example.com" ], "url_variant": "standard", "url": "https://sign.signatureapi.com/en/start?token=eyJhbGciOiJFUzI1NiIsInR..." } ``` # Redirect URL Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/ceremonies/redirect-url Configure where recipients are sent after completing, declining, or failing a signing ceremony. After a ceremony finishes (completed, declined, or failed), SignatureAPI redirects the recipient to the `redirect_url` you defined on the ceremony object. SignatureAPI appends the following query parameters to the URL: | Parameter | Description | | :---------------- | :---------------------------------------------------------------------------- | | `ceremony_result` | The outcome: `ceremony.completed`, `ceremony.declined`, or `ceremony.failed`. | | `envelope_id` | The ID of the envelope. | | `recipient_id` | The ID of the recipient. | For example, if `redirect_url` is `https://www.example.com`, a successful ceremony redirects to: `https://www.example.com/?ceremony_result=ceremony.completed&envelope_id=5b7be28c-6c7c-4aaa-b25f-66879e8d0957&recipient_id=re_0sgQC0cejYRC8wRsT5N9ll` Use these query parameters to process the ceremony result in your application. ## Redirect delay By default, the redirect happens 3 seconds after the ceremony finishes. Set the `redirect_delay` property to change this. ```json theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [{ "type": "email_code" }], "redirect_url": "https://www.example.com/success", "redirect_delay": 0 } ``` Set `redirect_delay` to `0` for an immediate redirect. The maximum value is `20` seconds. For embedded ceremonies, `redirect_delay` controls the delay before emitting `ceremony.completed`, `ceremony.declined`, or `ceremony.failed` [Ceremony Events](/docs/embedded/ceremony-events). Embedded ceremonies ignore the `redirect_url` and do not navigate away. Use [Ceremony Events](/docs/embedded/ceremony-events) to handle the outcome in embedded flows. # Create a deliverable Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/deliverables/create POST /v1/envelopes/{envelope_id}/deliverables Creates a new deliverable from a completed envelope. Creates a new [deliverable](/docs/api/resources/deliverables/object) from a completed [envelope](/docs/api/resources/envelopes/object). The envelope must have a `status` of `completed`. SignatureAPI already creates one deliverable automatically when an envelope completes. Use this endpoint to generate additional deliverables after that point. For example, create a simple deliverable containing only specific documents, or a password-protected copy for secure distribution. The deliverable starts in `processing` status and transitions to `generated` once the PDF is ready. This usually takes a few seconds. Subscribe to the [`deliverable.generated`](/docs/api/resources/events/deliverable-events#deliverable-generated) webhook to be notified when the deliverable is ready for download. Deliverables created using this endpoint are not sent automatically to recipients. ### Path Parameters The unique identifier of the envelope, in UUID format. ### Body Parameters The standard deliverable includes an audit log. To get signed documents without an audit log, use the [simple deliverable](/docs/api/resources/deliverables/simple) instead. A user-provided name for this deliverable. Use this to identify deliverables when an envelope has more than one. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Between 1 and 32 characters. The type of the deliverable. * `standard`: Includes the signed documents and an audit log with a certificate of completion. This is the default. * `simple`: Includes the signed documents only, without an audit log. For standard deliverables, the type is `standard`. The language for system-generated text in the audit log, including labels and the certificate of completion. Does not affect the content of the signed documents. Supported values: `en` (English), `es` (Spanish), `fr` (French), `it` (Italian), `pt` (Portuguese), `de` (German), `zh` (Chinese Simplified), `hu` (Hungarian). Defaults to the envelope language. The timezone used for timestamps in the audit log. Must be a valid IANA Time Zone Database identifier (e.g., `America/New_York`, `Europe/London`). Does not affect timestamps inside the signed documents. Defaults to the envelope timezone. The format for timestamps in the audit log. Uses MomentJS format tokens (e.g., `MM/DD/YYYY HH:mm:ss`). Does not affect timestamps inside the signed documents. Defaults to the envelope timestamp format. The keys of the documents to include in the deliverable. By default, all documents in the envelope are included. Use this to create a deliverable with only a subset of documents. For example, generate separate deliverables for different recipients. Accepts between 1 and 10 document keys. The password used to encrypt the deliverable. Recipients must enter this password to access the downloaded file. Password requirements: * Between 4 and 32 characters * Letters and numbers only (no special characters or spaces) When returned in API responses, the password value is masked for security (displayed as `********`). Password protection is available upon request. [Contact support](https://signatureapi.com/support) to enable this feature. The simple deliverable does not include an audit log. To get signed documents with an audit log, use the [standard deliverable](/docs/api/resources/deliverables/standard) instead. A user-provided name for this deliverable. Use this to identify deliverables when an envelope has more than one. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Between 1 and 32 characters. The type of the deliverable. * `standard`: Includes the signed documents and an audit log with a certificate of completion. This is the default. * `simple`: Includes the signed documents only, without an audit log. For simple deliverables, the type is `simple`. The keys of the documents to include in the deliverable. By default, all documents in the envelope are included. Use this to create a deliverable with only a subset of documents. For example, generate separate deliverables for different recipients. Accepts between 1 and 10 document keys. The password used to encrypt the deliverable. Recipients must enter this password to access the downloaded file. Password requirements: * Between 4 and 32 characters * Letters and numbers only (no special characters or spaces) When returned in API responses, the password value is masked for security (displayed as `********`). Password protection is available upon request. [Contact support](https://signatureapi.com/support) to enable this feature. ### Returns Returns a `201 Created` status code along with [a deliverable object](/docs/api/resources/deliverables/object) after successful creation, or an [error](/docs/api/errors) otherwise. ```json Standard theme={null} // POST https://api.signatureapi.com/v1/envelopes/{envelope_id}/deliverables // X-API-Key: key_test_... // Content-Type: application/json { "type": "standard" } ``` ```json Simple (No Audit Log) theme={null} // POST https://api.signatureapi.com/v1/envelopes/{envelope_id}/deliverables // X-API-Key: key_test_... // Content-Type: application/json { "type": "simple" } ``` ```json With Password theme={null} // POST https://api.signatureapi.com/v1/envelopes/{envelope_id}/deliverables // X-API-Key: key_test_... // Content-Type: application/json { "type": "standard", "password": "SecurePass123", "language": "en", "timezone": "America/New_York", "timestamp_format": "MM/DD/YYYY HH:mm:ss" } ``` ```json Specific Documents theme={null} // POST https://api.signatureapi.com/v1/envelopes/{envelope_id}/deliverables // X-API-Key: key_test_... // Content-Type: application/json { "type": "standard", "included_documents": ["contract", "addendum"] } ``` ```json Standard theme={null} // HTTP Status Code 201 { "id": "del_LXRDwyTeJDVrWXmjwxsAGPq", "name": null, "envelope_id": "4ec99c57-4430-4d73-8afd-912dcf4b5880", "type": "standard", "status": "processing", "url": null, "language": "en", "timezone": "America/New_York", "timestamp_format": "MM/DD/YYYY HH:mm:ss", "included_documents": ["contract", "addendum"], "password": null, "created_at": "2024-01-01T00:00:00Z", "generated_at": null } ``` ```json Simple (No Audit Log) theme={null} // HTTP Status Code 201 { "id": "del_MYSExzUfKEWsXYnkywsAGQr", "name": null, "envelope_id": "4ec99c57-4430-4d73-8afd-912dcf4b5880", "type": "simple", "status": "processing", "url": null, "included_documents": ["contract", "addendum"], "password": null, "created_at": "2024-01-01T00:00:00Z", "generated_at": null } ``` ```json With Password theme={null} // HTTP Status Code 201 { "id": "del_NZTFyAVgLFXtYZolzxtAHRs", "name": null, "envelope_id": "4ec99c57-4430-4d73-8afd-912dcf4b5880", "type": "standard", "status": "processing", "url": null, "language": "en", "timezone": "America/New_York", "timestamp_format": "MM/DD/YYYY HH:mm:ss", "included_documents": ["contract", "addendum"], "password": "********", "created_at": "2024-01-01T00:00:00Z", "generated_at": null } ``` ```json Specific Documents theme={null} // HTTP Status Code 201 { "id": "del_OATGzBWhMGYuZApmAyuBISt", "name": null, "envelope_id": "4ec99c57-4430-4d73-8afd-912dcf4b5880", "type": "standard", "status": "processing", "url": null, "language": "en", "timezone": "America/New_York", "timestamp_format": "MM/DD/YYYY HH:mm:ss", "included_documents": ["contract", "addendum"], "password": null, "created_at": "2024-01-01T00:00:00Z", "generated_at": null } ``` # Retrieve a deliverable Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/deliverables/get GET /v1/deliverables/{deliverable_id} Retrieves the details of a deliverable, including its current status and download URL. Retrieves the details of a deliverable, including its current status and download URL. When the deliverable `status` is `generated`, the response includes a `url` property with a download link. By default, this is a pre-signed URL that expires after 1 hour. Call this endpoint again to get a fresh URL if the previous one has expired. ### Path Parameters The unique identifier for this deliverable. ### Returns Returns a `200 OK` status code along with [a deliverable object](/docs/api/resources/deliverables/object) if successful, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // GET https://api.signatureapi.com/v1/deliverables/{deliverable_id} // X-API-Key: key_test_... ``` ```json Response theme={null} // HTTP Status Code 200 { "id": "del_LXRDwyTeJDVrWXmjwxsAGPq", "name": null, "envelope_id": "4ec99c57-4430-4d73-8afd-912dcf4b5880", "type": "standard", "status": "generated", "url": "https://vault.signatureapi.com/envelopes/4ec99c57-4430-4d73-8afd-912dcf4b5880/deliverables/del_LXRDwyTeJDVrWXmjwxsAGPq...", "language": "en", "timezone": "America/New_York", "timestamp_format": "MM/DD/YYYY HH:mm:ss", "included_documents": ["contract", "addendum"], "password": null, "created_at": "2024-01-01T00:00:00Z", "generated_at": "2024-01-01T00:01:00Z" } ``` # Deliverable Lifecycle Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/deliverables/lifecycle The lifecycle and statuses of a deliverable. A deliverable moves through the following statuses: | Status | Description | | ------------ | ---------------------------------------------------------------------------------------------------- | | `pending` | The envelope is not yet completed. The deliverable is waiting to be generated. | | `processing` | The envelope has completed and the deliverable is being generated. This usually takes a few seconds. | | `generated` | The deliverable is ready. The `url` property contains a download link. | | `failed` | The deliverable failed to generate. This is rare. SignatureAPI support is notified automatically. | Subscribe to the [`deliverable.generated`](/docs/api/resources/events/deliverable-events#deliverable-generated) webhook event to be notified when a deliverable is ready for download. # List deliverables Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/deliverables/list GET /v1/envelopes/{envelope_id}/deliverables Returns a list of all deliverables for an envelope. Returns a list of all deliverables for an envelope. Every completed envelope has at least one deliverable, created automatically when the envelope completes. Additional deliverables may exist if created via the [Create Deliverable](/docs/api/resources/deliverables/create) endpoint. Results are sorted chronologically by creation date, with the earliest deliverable appearing first. ### Path Parameters The unique identifier of the envelope, in UUID format. ### Query Parameters The maximum number of objects to return in the response, up to 20. The default is 20. For certain use cases we can increase the limit. Please contact [support](mailto:support@signatureapi.com). ### Returns Returns a `200 OK` status code along with a [paginated](/docs/api/pagination) list of [deliverable objects](/docs/api/resources/deliverables/object) if successful, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // GET https://api.signatureapi.com/v1/envelopes/{envelope_id}/deliverables // X-API-Key: key_test_... ``` ```json Response theme={null} // HTTP Status Code 200 { "links": { "next": null, "previous": null }, "data": [ { "id": "del_LXRDwyTeJDVrWXmjwxsAGPq", "name": null, "envelope_id": "4ec99c57-4430-4d73-8afd-912dcf4b5880", "type": "standard", "status": "generated", //... }, { "id": "del_MYSExzUfKEWsXYnkywsAGQr", "name": "hr_pack", "envelope_id": "4ec99c57-4430-4d73-8afd-912dcf4b5880", "type": "simple", "status": "generated", //... } ] } ``` # Deliverable Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/deliverables/object The deliverable object represents the final signed PDF generated when an envelope is completed. A deliverable is the final PDF generated when all recipients complete an envelope. It contains the signed documents and, depending on the type, an audit log with a certificate of completion. SignatureAPI automatically creates a deliverable when an envelope completes. You can also create additional deliverables manually using the [Create Deliverable](/docs/api/resources/deliverables/create) endpoint. A deliverable belongs to an [envelope](/docs/api/resources/envelopes/object). ## Types SignatureAPI offers two deliverable types: | Type | Description | | ----------------------------------------------------------------- | -------------------------------------------------------------------- | | [Standard deliverable](/docs/api/resources/deliverables/standard) | Includes the signed documents and an audit log. This is the default. | | [Simple deliverable](/docs/api/resources/deliverables/simple) | Includes the signed documents only, without an audit log. | ## Lifecycle A deliverable's `status` tracks its progress from creation to completion. See the [deliverable lifecycle](/docs/api/resources/deliverables/lifecycle) for details on each status. ## Attributes The standard deliverable includes an audit log. To get signed documents without an audit log, use the [simple deliverable](/docs/api/resources/deliverables/simple) instead. The unique identifier for this deliverable. A user-provided name for this deliverable. Use this to identify deliverables when an envelope has more than one. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Between 1 and 32 characters. The unique identifier of the envelope, in UUID format. The type of the deliverable. * `standard`: Includes the signed documents and an audit log with a certificate of completion. This is the default. * `simple`: Includes the signed documents only, without an audit log. For standard deliverables, the type is `standard`. The current status of the deliverable. * `pending`: The envelope is not yet completed. The deliverable is waiting to be generated. * `processing`: The envelope has completed and the deliverable is being generated. This usually takes a few seconds. * `generated`: The deliverable is ready. The `url` property contains a download link. * `failed`: The deliverable failed to generate. This is rare. SignatureAPI support is notified automatically. The URL for downloading the deliverable. `null` until the deliverable reaches `generated` status. By default, this is a pre-signed URL. It requires no additional authentication and expires after 1 hour. If the link has expired, retrieve the deliverable again to get a fresh URL. If your account uses authenticated URLs (for HIPAA compliance, for example), access this URL with your API key as you would any other API request. Authenticated URLs do not expire. The language for system-generated text in the audit log, including labels and the certificate of completion. Does not affect the content of the signed documents. Supported values: `en` (English), `es` (Spanish), `fr` (French), `it` (Italian), `pt` (Portuguese), `de` (German), `zh` (Chinese Simplified), `hu` (Hungarian). Defaults to the envelope language. The timezone used for timestamps in the audit log. Must be a valid IANA Time Zone Database identifier (e.g., `America/New_York`, `Europe/London`). Does not affect timestamps inside the signed documents. Defaults to the envelope timezone. The format for timestamps in the audit log. Uses MomentJS format tokens (e.g., `MM/DD/YYYY HH:mm:ss`). Does not affect timestamps inside the signed documents. Defaults to the envelope timestamp format. The keys of the documents to include in the deliverable. By default, all documents in the envelope are included. Use this to create a deliverable with only a subset of documents. For example, generate separate deliverables for different recipients. Accepts between 1 and 10 document keys. The password used to encrypt the deliverable. Recipients must enter this password to access the downloaded file. Password requirements: * Between 4 and 32 characters * Letters and numbers only (no special characters or spaces) When returned in API responses, the password value is masked for security (displayed as `********`). Password protection is available upon request. [Contact support](https://signatureapi.com/support) to enable this feature. The time the deliverable was created, in ISO 8601 format. Set when the envelope is created, or when a deliverable is created via the API. The time the deliverable was successfully generated, in ISO 8601 format. `null` until the deliverable reaches `generated` status. The simple deliverable does not include an audit log. To get signed documents with an audit log, use the [standard deliverable](/docs/api/resources/deliverables/standard) instead. The unique identifier for this deliverable. A user-provided name for this deliverable. Use this to identify deliverables when an envelope has more than one. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Between 1 and 32 characters. The unique identifier of the envelope, in UUID format. The type of the deliverable. * `standard`: Includes the signed documents and an audit log with a certificate of completion. This is the default. * `simple`: Includes the signed documents only, without an audit log. For simple deliverables, the type is `simple`. The current status of the deliverable. * `pending`: The envelope is not yet completed. The deliverable is waiting to be generated. * `processing`: The envelope has completed and the deliverable is being generated. This usually takes a few seconds. * `generated`: The deliverable is ready. The `url` property contains a download link. * `failed`: The deliverable failed to generate. This is rare. SignatureAPI support is notified automatically. The URL for downloading the deliverable. `null` until the deliverable reaches `generated` status. By default, this is a pre-signed URL. It requires no additional authentication and expires after 1 hour. If the link has expired, retrieve the deliverable again to get a fresh URL. If your account uses authenticated URLs (for HIPAA compliance, for example), access this URL with your API key as you would any other API request. Authenticated URLs do not expire. The keys of the documents to include in the deliverable. By default, all documents in the envelope are included. Use this to create a deliverable with only a subset of documents. For example, generate separate deliverables for different recipients. Accepts between 1 and 10 document keys. The password used to encrypt the deliverable. Recipients must enter this password to access the downloaded file. Password requirements: * Between 4 and 32 characters * Letters and numbers only (no special characters or spaces) When returned in API responses, the password value is masked for security (displayed as `********`). Password protection is available upon request. [Contact support](https://signatureapi.com/support) to enable this feature. The time the deliverable was created, in ISO 8601 format. Set when the envelope is created, or when a deliverable is created via the API. The time the deliverable was successfully generated, in ISO 8601 format. `null` until the deliverable reaches `generated` status. ```json Standard theme={null} // HTTP Status Code 200 { "id": "del_LXRDwyTeJDVrWXmjwxsAGPq", "name": null, "envelope_id": "52872f0e-b919-4d69-89cd-e7e56af00548", "type": "standard", "status": "generated", "url": "https://vault.signatureapi.com/envelopes/52872f0e-b919-4d69-89cd-e7e56af00548/deliverables/del_LXRDwyTeJDVrWXmjwxsAGPq...", "language": "en", "timezone": "America/New_York", "timestamp_format": "MM/DD/YYYY HH:mm:ss", "included_documents": ["contract", "addendum"], "password": null, "created_at": "2024-01-01T00:00:00Z", "generated_at": "2024-01-01T00:01:00Z" } ``` ```json Simple theme={null} // HTTP Status Code 200 { "id": "del_MYSExzUfKEWsXYnkywsAGQr", "name": null, "envelope_id": "52872f0e-b919-4d69-89cd-e7e56af00548", "type": "simple", "status": "generated", "url": "https://vault.signatureapi.com/envelopes/52872f0e-b919-4d69-89cd-e7e56af00548/deliverables/del_MYSExzUfKEWsXYnkywsAGQr...", "included_documents": ["contract", "addendum"], "password": null, "created_at": "2024-01-01T00:00:00Z", "generated_at": "2024-01-01T00:01:00Z" } ``` # Protect your deliverable with a password Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/deliverables/password Protect your deliverable with password encryption. You can protect a deliverable with password encryption by including a `password` property in your request. Recipients must enter the password to open the PDF. The deliverable PDF is encrypted with AES-128 encryption. ```json Deliverable (Request) theme={null} { "type": "standard", "password": "SecurePass123", //... } ``` Password protection must be enabled on your account before use. [Contact support](https://signatureapi.com/support) to enable this feature. ## Password Requirements * Between 4 and 32 characters * Uppercase letters (A-Z), lowercase letters (a-z), and numbers (0-9) only * Special characters are not supported due to PDF reader compatibility For strong protection, use at least 12 characters with a random mix of uppercase letters, lowercase letters, and numbers. ## API Response In API responses, the password is always masked as `********`. ```json Deliverable (Response) theme={null} { "type": "standard", "password": "********", //... } ``` # Simple Deliverable Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/deliverables/simple Generate a signed PDF that includes only the signed documents, without an audit log. The simple deliverable is a PDF that contains only the signed documents. No audit log pages are included in the output. The audit log is still embedded as metadata within the PDF for verification purposes. Use a simple deliverable when you want a clean document without the audit log visible in the PDF pages. If you need the audit log included in the PDF, use the [standard deliverable](/docs/api/resources/deliverables/standard) instead. SignatureAPI deliverables are tamper-proof and secured with a cryptographic seal that [verifies their authenticity](/docs/api/resources/deliverables/verification). ## Example Download an example of a simple deliverable. ## Generating a Simple Deliverable You can generate a simple deliverable in two ways: automatically when the envelope completes, or manually using the Create Deliverable endpoint. ### Automatic (On Envelope Completion) To generate a simple deliverable instead of the default standard deliverable, set the `deliverable` property when creating the envelope: ```json Create Envelope (Request) theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "documents": [ //... ], "recipients": [ //... ], "deliverable": { "type": "simple" } } ``` ### Manual (Create Deliverable Endpoint) You can also create a simple deliverable manually at any time after the envelope completes, using the [Create Deliverable](/docs/api/resources/deliverables/create) endpoint. ```json Create Deliverable (Request) theme={null} // POST https://api.signatureapi.com/v1/envelopes/{envelope_id}/deliverables // X-API-Key: key_test_... // Content-Type: application/json { "type": "simple" } ``` ## Customization ### Included Documents The `included_documents` property specifies which documents from the envelope to include in the deliverable. By default, all documents are included. Accepts between 1 and 10 document keys. Use this to generate separate deliverables for different documents, or to exclude certain documents from the final PDF. ```json theme={null} { "type": "simple", "included_documents": ["contract", "addendum"] } ``` ## Password Protection To protect your deliverable with password encryption, see [Password Protection](/docs/api/resources/deliverables/password). ## Keep Learning * Follow the [Get Deliverables Without the Audit Log](/docs/api/guides/how-to/deliverable-without-audit-log) guide for a step-by-step walkthrough. * [Download signed documents](/docs/api/guides/use-cases/save-signed-documents) automatically using webhooks. # Standard Deliverable Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/deliverables/standard Generate a signed PDF that includes the signed documents and a detailed audit log of the signing process. The standard deliverable is a PDF that contains both the signed documents and an audit log. The audit log records every action taken during the signing process and includes a certificate of completion. This is the default deliverable type. SignatureAPI deliverables are tamper-proof and secured with a cryptographic seal that [verifies their authenticity](/docs/api/resources/deliverables/verification). ## Example Download an example of a standard deliverable. ## Generating a Standard Deliverable You can generate a standard deliverable in two ways: automatically when the envelope completes, or manually using the Create Deliverable endpoint. ### Automatic (On Envelope Completion) By default, SignatureAPI automatically generates a standard deliverable when an envelope completes. The deliverable is sent to recipients when it is ready. The deliverable inherits the envelope's `language`, `timezone`, and `timestamp_format` settings. You can override these by including a `deliverable` object when creating the envelope. For example, to set the deliverable's audit log language to English while the envelope uses French: ```json Create Envelope (Request) theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "language": "fr", "documents": [ //... ], "recipients": [ //... ], "deliverable": { "type": "standard", "language": "en" } } ``` ### Manual (Create Deliverable Endpoint) You can also create a standard deliverable manually at any time after the envelope completes, using the [Create Deliverable](/docs/api/resources/deliverables/create) endpoint. ```json Create Deliverable (Request) theme={null} // POST https://api.signatureapi.com/v1/envelopes/{envelope_id}/deliverables // X-API-Key: key_test_... // Content-Type: application/json { "type": "standard" } ``` ## Customization ### Language The `language` property sets the language for system-generated text in the audit log, such as labels and the certificate of completion. It does not affect the content of the signed documents. See [available languages](/docs/api/resources/envelopes/language). Defaults to the envelope language. ### Timezone The `timezone` property sets the timezone for timestamps in the audit log. It does not affect timestamps inside the signed documents. See [available timezones](/docs/api/resources/envelopes/timezone). Defaults to the envelope timezone. ### Timestamp Format The `timestamp_format` property sets the format for timestamps in the audit log. It does not affect timestamps inside the signed documents. See [available timestamp formats](/docs/api/resources/envelopes/timestamp-format). Defaults to the envelope timestamp format. ### Included Documents The `included_documents` property specifies which documents from the envelope to include in the deliverable. By default, all documents are included. Accepts between 1 and 10 document keys. Use this to generate separate deliverables for different documents, or to exclude certain documents from the final PDF. ```json theme={null} { "type": "standard", "included_documents": ["contract", "addendum"] } ``` ## Password Protection To protect your deliverable with password encryption, see [Password Protection](/docs/api/resources/deliverables/password). # Verify a Deliverable Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/deliverables/verification Verify the cryptographic signature on SignatureAPI PDF deliverables using public key certificates. All SignatureAPI PDF deliverables are sealed with a cryptographic signature. You can verify that a deliverable was generated by SignatureAPI and has not been altered since it was issued. The signature is created using one of these public key certificates: | | | | ------------------- | ------------------------------------------------------------------ | | Serial Number | `0FE117EE6AF5B1EECC367D06D7845D17` | | SHA-256 Fingerprint | `843AA9BB894A3C9956F6CD3F06E0D6E9E43F0A192849977F747F918A1C4F4F7E` | | | | | ------------------- | ------------------------------------------------------------------ | | Serial Number | `2979AC8352AC3B82B72EAA318FFFA49D` | | SHA-256 Fingerprint | `815B8B425132FEB359334E4589CC8C7FE78C3F6DC976AB403825DFAC4F0B8CA2` | | | | | ------------------- | ------------------------------------------------------------------ | | Serial Number | `2E8766982802E57E49D02FA3907DCDCE` | | SHA-256 Fingerprint | `CBD80A0B0B3F212C30590AF00DE75692D11CA9EA49C9B86FD82441BBB0A95BFA` | | | | | ------------------- | ------------------------------------------------------------------------------------------------- | | Serial Number | `3C2A804C599D18452298B145296FD433` | | SHA-256 Fingerprint | `1B:F6:EA:62:5A:52:E5:36:B2:D9:0F:DA:8B:28:0A:41:58:11:80:7D:4F:B9:24:25:3A:A2:E1:84:C1:30:CC:46` | | | | | ------------------- | ------------------------------------------------------------------ | | Serial Number | `533ECFDBD0D3D876C4D452E2268A3F35` | | SHA-256 Fingerprint | `DC0B3B18804DC36ECE893C4A4D1C03F156C1D14F5991599DD85DFB9F6D1F7F60` | | | | | ------------------- | ------------------------------------------------------------------ | | Serial Number | `5DC2DACB8E8B3A32A387FBBED05FD79C` | | SHA-256 Fingerprint | `0638C6E40EB36D081A1FF578BCDB26799C96716CE4C021F3DB9B9CDC79CB0497` | ## Verifying in Adobe Acrobat The easiest way to verify a deliverable is to open it in Adobe Acrobat Reader (free) or Adobe Acrobat (paid). **Step 1: Check that the signature is valid.** You should see a signature icon with a green check mark and the message "Signed and all signatures are valid." Valid Signature Message in Adobe Acrobat **Step 2: Open the Signature Panel.** Click the signature panel to review the signer identity and confirm that the certificate matches one of the SignatureAPI certificates listed above. This confirms the deliverable was generated by SignatureAPI and has not been modified since it was sealed. # Document Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/documents/object The document object represents a PDF or DOCX file within an envelope A **document** is a PDF or DOCX file within an [envelope](/docs/api/resources/envelopes/object). Each envelope can contain between 1 and 10 documents. Recipients sign, approve, or prepare documents during their [ceremony](/docs/api/resources/ceremonies/object). Documents are defined inside the `documents` array when [creating an envelope](/docs/api/resources/envelopes/create). They are not created or updated independently. A document belongs to an [envelope](/docs/api/resources/envelopes/object). ## Document formats SignatureAPI supports two document formats. You must set the `format` property to match the file type. **PDF** (`format: "pdf"`) accepts standard PDF files. Place fields using [placeholders](#place-positioning) embedded in the document text or [fixed coordinates](#place-positioning) on a page. **DOCX** (`format: "docx"`) accepts Microsoft Word files. In addition to places, DOCX documents support [template fields](/docs/api/resources/documents/templates) that merge dynamic data into the document before signing begins. If you upload a DOCX file but omit `format` or set it to `"pdf"`, the API returns a [cannot-parse-document](/docs/v1/errors/cannot-parse-document) error. Always set `format: "docx"` for Word files. DOCX files created with Google Docs or LibreOffice may not be compatible. If you get a [cannot-parse-document](/docs/v1/errors/cannot-parse-document) error, open the file in Microsoft Word and re-save it. This resolves most compatibility issues. ## Providing a file Set the `url` property to a publicly accessible URL for the file. SignatureAPI downloads the file when the envelope is created. You can host files on Amazon S3, Google Cloud Storage, Azure Blob Storage, Cloudflare R2, and other services. You can also [upload files directly to SignatureAPI](/docs/api/resources/documents/url) and use the returned URL. ## Places [Places](/docs/api/resources/places/object) are areas in a document where recipients interact or where information is displayed automatically. Input places include signatures, initials, text inputs, checkboxes, and dropdowns. Informational places include static text, completion dates, and recipient details. Define places in the `places` array. Each place has a `key` and a `type`. ## Place positioning A place must be positioned in the document. There are two methods. **Placeholders**: Embed `[[place_key]]` in the document text. The place appears at that location. This works for both PDF and DOCX documents. **Fixed positions**: Specify the `page`, `top`, and `left` values in the `fixed_positions` array. Coordinates are measured in points (1 point = 1/72 inch) from the top-left corner of the page. See [Place Positioning](/docs/api/resources/places/positioning) for details and examples. ## Attributes The unique identifier of the document. Document IDs start with `doc_`. The unique identifier of the envelope, in UUID format. A user-provided identifier for this document within the envelope. Must be unique within the envelope. Use the key to reference this document in other parts of the API. Only lowercase letters, numbers, and underscores are allowed. Must start with a letter. Maximum 32 characters. If not provided, a key is generated automatically. An optional display name for the document. When set, the title is shown to recipients during the signing ceremony and in deliverables. Defaults to `null` if not provided. Maximum 500 characters. The total number of pages in the document after processing. For DOCX templates, this reflects the page count after template data has been merged. The URL where the document or template file is located. The file must be publicly accessible. You can host files on Amazon S3, Google Cloud Storage, Azure Blob Storage, Cloudflare R2, and other services. You can also use the URL returned by the [Create Upload](/docs/api/resources/uploads/create) endpoint. Learn more about your options in [Document URL and Upload](/docs/api/resources/documents/url). The file format of the document. Determines which features are available. * `pdf` -- Standard PDF file. Supports places via placeholders or fixed positions. * `docx` -- Microsoft Word file. Supports template fields for dynamic content in addition to places. For PDF documents the format is `pdf`. The key of the place to position. Must match one of the `key` values in the document's `places` array. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The page number where the place is positioned. Page numbering starts at 1. The vertical distance from the top edge of the page to the bottom-left corner of the place, measured in points (1 point = 1/72 of an inch). For example, `360` places the field 5 inches from the top edge. The horizontal distance from the left edge of the page to the bottom-left corner of the place, measured in points (1 point = 1/72 of an inch). For example, `72` places the field 1 inch from the left edge. Areas within a document where a recipient provides input (such as a signature or text) or where a value is displayed automatically (such as a completion date). Each place has a `type` that determines its behavior. A place must be positioned using either a `[[place_key]]` placeholder in the document text or an entry in the `fixed_positions` array. Learn more about [places](/docs/api/resources/places/object). A location where the recipient, identified by `recipient_key`, draws or types their signature. A single recipient can have multiple signature places across different pages of a document. Specifies the type of place. For a signature place, the value must be `signature`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the signature place in points. The width is calculated automatically using a 5:2 ratio based on this height. Must be between 20 and 60. Defaults to 60. A location where the recipient, identified by `recipient_key`, enters their initials. A single recipient can have multiple initials places across different pages of a document. Specifies the type of place. For an initials place, the value must be `initials`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the initials place in points. The width equals the height. Must be between 20 and 60. Defaults to 60. A read-only text value displayed at a specific location on the document. It is not interactive and does not require a recipient. Use this to pre-fill static information such as company names, reference numbers, or dates before the signing process begins. Specifies the type of place. For a text place, the value must be `text`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The text content to display on the document. This is a static value set when the envelope is created and cannot be changed by the recipient. Maximum length is 1000 characters. The font size in points. Must be between 1 and 144. The default is 12. The font color for this text place. Must be a six-digit hex color code with a leading `#`. Defaults to `#000000` (black). A location where the recipient, identified by `recipient_key`, types free-form text. Supports input validation, placeholder text, and tooltip hints. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a text input place, the value must be `text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. Defines the validation format for the user’s input. Accepted values: * `email` * `zipcode-us` * a custom regular expression, enclosed in `/`, for example: `/^[a-z0-9]{1,10}$/` Learn more in [Format Validation](/docs/api/resources/places/text-input#format-validation). The message displayed when the user’s input does not match the required format. Learn more in [Format Validation -> Adding a Custom Message](/docs/api/resources/places/text-input#adding-a-custom-message). The initial width of the text input field in points. The field may expand beyond this width during typing. Must be between 30 and 540. Defaults to 30. The font size in points. Must be between 6 and 12. Defaults to 12. A series of individual character boxes where the recipient, identified by `recipient_key`, enters text one character per box. Use this for structured data such as verification codes, ZIP codes, or the last four digits of an SSN. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a boxed text input place, the value must be `boxed_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The number of individual character boxes to display. Must be between 1 and 100. Each box accepts a single character from the recipient. Specifies whether the recipient must fill all boxes to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. A placeholder message shown inside the first box during the signing ceremony to guide the recipient. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). A tooltip message displayed over the boxed text input field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The total width of the boxed input field in points. Must be between 30 and 540. The default is 30. The height of each individual box in points. The font size in points. Must be between 6 and 12. The default is 12. A location where the recipient, identified by `recipient_key`, enters text that spans multiple lines. Use this for comments, addresses, and longer descriptions. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a multi-line text input place, the value must be `multiline_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The width of the multi-line text input place in points. Must be between 30 and 540. The default is 30. The number of lines for the multi-line text input field. Must be between 1 and 100. The line height in points. Must be greater than or equal to `font_size`. Must be between 6 and 72. The default is 12. The font size in points. Must be between 6 and 12. The default is 12. A location where the recipient, identified by `recipient_key`, checks or unchecks a box. Use `capture_as` to store the checkbox value in the envelope's captures. Specifies the type of place. For a checkbox place, the value must be `checkbox`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The symbol to display in the checkbox when it is checked. Available options are `check` and `xmark`. The default is `check`. Specifies whether the recipient must check this box to complete the signing ceremony. Possible values are `required` or `optional`. The default is `optional`. The height of the checkbox in points. The width equals the height. Must be between 8 and 40. Defaults to 20. A location where the recipient, identified by `recipient_key`, selects from a list of options. Options can be a custom list of label-value pairs or a predefined set such as country names or US state codes. Use `capture_as` to store the selected value in the envelope's captures. Specifies the type of place. For a dropdown place, the value must be `dropdown`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The list of options available in the dropdown. Either an array of custom `label`/`value` pairs, or a string specifying a predefined option set such as `us_states_names` or `world_countries_names`. The pre-selected option when the dropdown is displayed. The display behavior of the dropdown. Possible values: `auto`, `select`, or `combobox`. Whether the recipient must select an option. Possible values: `required` or `optional`. A placeholder message shown inside the dropdown field during the signing ceremony. A tooltip message displayed when the user hovers over or focuses on the dropdown field. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The font size in points for the dropdown field. The width of the dropdown field in points. Displays the date and time when the recipient, identified by `recipient_key`, completed their action on the envelope. Use `date_format` to control how the date is formatted. Specifies the type of place. For this kind of place, the value must be `recipient_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. Displays the date and time when the envelope was completed. The envelope completes when all recipients have finished their actions. Use `date_format` to control how the date is formatted. Specifies the type of place. For this kind of place, the value must be `envelope_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. Displays the name of the recipient, identified by `recipient_key`, at a specific location on the document. The value is inserted automatically. This place is read-only and does not require any action from the recipient. Specifies the type of place. For this kind of place, the value must be `recipient_name`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. Displays the email address of the recipient, identified by `recipient_key`, at a specific location on the document. The value is inserted automatically. This place is read-only and does not require any action from the recipient. Specifies the type of place. For this kind of place, the value must be `recipient_email`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The unique identifier of the document. Document IDs start with `doc_`. The unique identifier of the envelope, in UUID format. A user-provided identifier for this document within the envelope. Must be unique within the envelope. Use the key to reference this document in other parts of the API. Only lowercase letters, numbers, and underscores are allowed. Must start with a letter. Maximum 32 characters. If not provided, a key is generated automatically. An optional display name for the document. When set, the title is shown to recipients during the signing ceremony and in deliverables. Defaults to `null` if not provided. Maximum 500 characters. The total number of pages in the document after processing. For DOCX templates, this reflects the page count after template data has been merged. The URL where the document or template file is located. The file must be publicly accessible. You can host files on Amazon S3, Google Cloud Storage, Azure Blob Storage, Cloudflare R2, and other services. You can also use the URL returned by the [Create Upload](/docs/api/resources/uploads/create) endpoint. Learn more about your options in [Document URL and Upload](/docs/api/resources/documents/url). The file format of the document. Determines which features are available. * `pdf` -- Standard PDF file. Supports places via placeholders or fixed positions. * `docx` -- Microsoft Word file. Supports template fields for dynamic content in addition to places. For DOCX documents the format is `docx`. Template data used to fill dynamic fields in a DOCX template. Each key corresponds to a `{{key}}` placeholder in the template file. Keys must be alphanumeric and at most 32 characters. Values can be strings, booleans, or nested objects. Nested keys map to dot-notation placeholders (for example, a key `person` with nested key `name` fills `{{person.name}}`). Defaults to `{}`. The key of the place to position. Must match one of the `key` values in the document's `places` array. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The page number where the place is positioned. Page numbering starts at 1. The vertical distance from the top edge of the page to the bottom-left corner of the place, measured in points (1 point = 1/72 of an inch). For example, `360` places the field 5 inches from the top edge. The horizontal distance from the left edge of the page to the bottom-left corner of the place, measured in points (1 point = 1/72 of an inch). For example, `72` places the field 1 inch from the left edge. Areas within a document where a recipient provides input (such as a signature or text) or where a value is displayed automatically (such as a completion date). Each place has a `type` that determines its behavior. A place must be positioned using either a `[[place_key]]` placeholder in the document text or an entry in the `fixed_positions` array. Learn more about [places](/docs/api/resources/places/object). A location where the recipient, identified by `recipient_key`, draws or types their signature. A single recipient can have multiple signature places across different pages of a document. Specifies the type of place. For a signature place, the value must be `signature`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the signature place in points. The width is calculated automatically using a 5:2 ratio based on this height. Must be between 20 and 60. Defaults to 60. A location where the recipient, identified by `recipient_key`, enters their initials. A single recipient can have multiple initials places across different pages of a document. Specifies the type of place. For an initials place, the value must be `initials`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the initials place in points. The width equals the height. Must be between 20 and 60. Defaults to 60. A read-only text value displayed at a specific location on the document. It is not interactive and does not require a recipient. Use this to pre-fill static information such as company names, reference numbers, or dates before the signing process begins. Specifies the type of place. For a text place, the value must be `text`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The text content to display on the document. This is a static value set when the envelope is created and cannot be changed by the recipient. Maximum length is 1000 characters. The font size in points. Must be between 1 and 144. The default is 12. The font color for this text place. Must be a six-digit hex color code with a leading `#`. Defaults to `#000000` (black). A location where the recipient, identified by `recipient_key`, types free-form text. Supports input validation, placeholder text, and tooltip hints. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a text input place, the value must be `text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. Defines the validation format for the user’s input. Accepted values: * `email` * `zipcode-us` * a custom regular expression, enclosed in `/`, for example: `/^[a-z0-9]{1,10}$/` Learn more in [Format Validation](/docs/api/resources/places/text-input#format-validation). The message displayed when the user’s input does not match the required format. Learn more in [Format Validation -> Adding a Custom Message](/docs/api/resources/places/text-input#adding-a-custom-message). The initial width of the text input field in points. The field may expand beyond this width during typing. Must be between 30 and 540. Defaults to 30. The font size in points. Must be between 6 and 12. Defaults to 12. A series of individual character boxes where the recipient, identified by `recipient_key`, enters text one character per box. Use this for structured data such as verification codes, ZIP codes, or the last four digits of an SSN. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a boxed text input place, the value must be `boxed_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The number of individual character boxes to display. Must be between 1 and 100. Each box accepts a single character from the recipient. Specifies whether the recipient must fill all boxes to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. A placeholder message shown inside the first box during the signing ceremony to guide the recipient. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). A tooltip message displayed over the boxed text input field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The total width of the boxed input field in points. Must be between 30 and 540. The default is 30. The height of each individual box in points. The font size in points. Must be between 6 and 12. The default is 12. A location where the recipient, identified by `recipient_key`, enters text that spans multiple lines. Use this for comments, addresses, and longer descriptions. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a multi-line text input place, the value must be `multiline_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The width of the multi-line text input place in points. Must be between 30 and 540. The default is 30. The number of lines for the multi-line text input field. Must be between 1 and 100. The line height in points. Must be greater than or equal to `font_size`. Must be between 6 and 72. The default is 12. The font size in points. Must be between 6 and 12. The default is 12. A location where the recipient, identified by `recipient_key`, checks or unchecks a box. Use `capture_as` to store the checkbox value in the envelope's captures. Specifies the type of place. For a checkbox place, the value must be `checkbox`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The symbol to display in the checkbox when it is checked. Available options are `check` and `xmark`. The default is `check`. Specifies whether the recipient must check this box to complete the signing ceremony. Possible values are `required` or `optional`. The default is `optional`. The height of the checkbox in points. The width equals the height. Must be between 8 and 40. Defaults to 20. A location where the recipient, identified by `recipient_key`, selects from a list of options. Options can be a custom list of label-value pairs or a predefined set such as country names or US state codes. Use `capture_as` to store the selected value in the envelope's captures. Specifies the type of place. For a dropdown place, the value must be `dropdown`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The list of options available in the dropdown. Either an array of custom `label`/`value` pairs, or a string specifying a predefined option set such as `us_states_names` or `world_countries_names`. The pre-selected option when the dropdown is displayed. The display behavior of the dropdown. Possible values: `auto`, `select`, or `combobox`. Whether the recipient must select an option. Possible values: `required` or `optional`. A placeholder message shown inside the dropdown field during the signing ceremony. A tooltip message displayed when the user hovers over or focuses on the dropdown field. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The font size in points for the dropdown field. The width of the dropdown field in points. Displays the date and time when the recipient, identified by `recipient_key`, completed their action on the envelope. Use `date_format` to control how the date is formatted. Specifies the type of place. For this kind of place, the value must be `recipient_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. Displays the date and time when the envelope was completed. The envelope completes when all recipients have finished their actions. Use `date_format` to control how the date is formatted. Specifies the type of place. For this kind of place, the value must be `envelope_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. Displays the name of the recipient, identified by `recipient_key`, at a specific location on the document. The value is inserted automatically. This place is read-only and does not require any action from the recipient. Specifies the type of place. For this kind of place, the value must be `recipient_name`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. Displays the email address of the recipient, identified by `recipient_key`, at a specific location on the document. The value is inserted automatically. This place is read-only and does not require any action from the recipient. Specifies the type of place. For this kind of place, the value must be `recipient_email`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. ```json PDF document theme={null} // HTTP Status Code 200 { "id": "doc_3jBYlxa9gv0fGLzFAnfwxe", "envelope_id": "5e5ace5e-bd1e-4d5a-bb1f-6a2b2e42cd13", "key": "agreement", "title": "Service Agreement", "page_count": 3, "url": "https://pub-e5051420e98a4fdfb3fd42a62fbf06fa.r2.dev/agreement.pdf", "format": "pdf", "fixed_positions": [ { "place_key": "provider_signs_here", "page": 3, "top": 600, "left": 72 } ], "places": [ { "key": "provider_signs_here", "type": "signature", "recipient_key": "service_provider", "height": 60 }, { "key": "client_signs_here", "type": "signature", "recipient_key": "client", "height": 60 } ] } ``` ```json DOCX document theme={null} // HTTP Status Code 200 { "id": "doc_8hKpmnFR6CFr6oChasgVb9", "envelope_id": "5e5ace5e-bd1e-4d5a-bb1f-6a2b2e42cd13", "key": "agreement", "title": "Service Agreement", "page_count": 2, "url": "https://pub-e5051420e98a4fdfb3fd42a62fbf06fa.r2.dev/agreement-template.docx", "format": "docx", "data": { "date": "December 31st, 2025", "serviceProvider": { "name": "Jane Smith", "organization": "ACME Global, Inc." }, "client": { "name": "Michael J. Miller", "organization": "Miller Industries" } }, "fixed_positions": [], "places": [ { "key": "provider_signs_here", "type": "signature", "recipient_key": "service_provider", "height": 60 }, { "key": "client_signs_here", "type": "signature", "recipient_key": "client", "height": 60 } ] } ``` # Document Templates Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/documents/templates Generate documents from DOCX templates and dynamic data. SignatureAPI can generate a document from a static DOCX template combined with dynamic data you provide. Use this to create personalized documents without editing files manually before each send. To add signature fields or display dynamic values like a recipient's name, see [Places](/docs/api/resources/places/object). ## How it works Create a DOCX file and embed **fields** and **conditionals** using double curly braces: `{{key}}`. When you create an envelope, provide the data in the `data` property of the document. SignatureAPI merges the template with your data and produces the final document. Provide the template URL in the `url` property and set `format` to `docx`. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Exploration Agreement", "documents": [ { "url": "https://www.example.com/agreement-template.docx", "format": "docx", "data": { "person": { "name": "Sherlock Holmes", "address": "221b Baker Street, London" }, "jurisdiction": "The United Kingdom", "mediation": false } } ], //... } ``` DOCX files created with software other than Microsoft Word (like Google Docs or LibreOffice) may not process correctly. If you get a [cannot-parse-document](/docs/v1/errors/cannot-parse-document) error, open the file in Microsoft Word and save it again. Contact support if you don't have Microsoft Word. **`{{double curly braces}}` vs `[[double brackets]]`**: these serve different purposes: * `{{field_key}}`: **Template fields.** Inject dynamic content (names, dates, addresses) into the document text before signing. Only available in DOCX documents. * `[[place_key]]`: **Place placeholders.** Position signature fields, text inputs, checkboxes, and other interactive places. Works in both PDF and DOCX documents. See [Place Positioning](/docs/api/resources/places/positioning). A DOCX document can use both: `{{}}` to inject content and `[[]]` to position places. ## Fields Fields mark locations in the template where data is inserted. Use double curly braces to define a field: `{{key}}`. **Template:**
This agreement is entered into by \{\{name}}.
**Data:** ```json theme={null} { "name": "Sherlock Holmes" } ``` **Result:**
This agreement is entered into by Sherlock Holmes.
### Nested objects Data values can be nested objects. Use dot notation in the template to reference nested keys. **Template:**
This agreement is entered into by \{\{person.name}}, residing at \{\{person.address.houseNumber}} \{\{person.address.streetName}}, \{\{person.address.city}}.
**Data:** ```json theme={null} { "person": { "name": "Sherlock Holmes", "address": { "houseNumber": "221b", "streetName": "Baker Street", "city": "London" } } } ``` **Result:**
This agreement is entered into by Sherlock Holmes, residing at 221b Baker Street, London.
## Conditionals Conditionals control which sections appear in the final document based on your data. ### If Use `{{if condition}}` and `{{endif}}` to show or hide a block of content. **Template:**
Please read before proceeding. \{\{if showDisclaimer}}
Information provided is for educational purposes only and should not be considered as professional advice.
\{\{endif}} Use at your own discretion.
With `"showDisclaimer": true`, the disclaimer appears. With `"showDisclaimer": false`, it is omitted. ### If-Else Use `{{if condition}}`, `{{else}}`, and `{{endif}}` to display one of two blocks based on a condition. **Template:**
\{\{if mediation}}
Any dispute shall be resolved by mediation, with each party bearing its own costs.
\{\{else}}
Any dispute shall be settled by arbitration, and the arbitrator's decision is final.
\{\{endif}}
With `"mediation": true`:
Any dispute shall be resolved by mediation, with each party bearing its own costs.
With `"mediation": false`:
Any dispute shall be settled by arbitration, and the arbitrator's decision is final.
# Document URL and Upload Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/documents/url Upload PDF or DOCX files via the dashboard, API, or external storage like S3 or Azure Every document in an envelope requires a `url` pointing to a PDF or DOCX file. SignatureAPI downloads the file when the envelope is created. There are three ways to provide a file URL: * [Upload via the Dashboard](#upload-via-dashboard) * [Upload via the API](#upload-via-api) * [Host it externally](#external-store) on a service like S3 or Azure ## Upload via Dashboard Upload files to your account's **Library** in the Dashboard. Library files never expire and can be reused across multiple envelopes. This method works well for recurring documents and templates. To upload a file, go to the **Library** tab in the Dashboard. Click **Upload a file** or drag and drop your file, then confirm the upload. Click **Copy URL** to copy the file URL. Use the URL in your document definition: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "documents": [ { "url": "https://api.signatureapi.com/v1/uploads/upl_7kWstHtxXmje18omrlV6OA#agreement-v1", "format": "pdf" //... } ], "recipients": [ //... ] //... } ``` ## Upload via API Use the [Create Upload](/docs/api/resources/uploads/create) endpoint to upload files programmatically. API uploads are temporary and intended for immediate use. To reuse a file, upload it to your Library in the Dashboard instead. The response from the Create Upload endpoint includes a `url` property. Use it as the document URL: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "documents": [ { "url": "https://api.signatureapi.com/v1/uploads/upl_7kWstHtxXmje18omrlV6OA", "format": "pdf" //... } ], "recipients": [ //... ] //... } ``` ## External Store You can provide any publicly accessible URL. SignatureAPI downloads the file from the specified location. Supported hosting services: Use either pre-signed (recommended) or public URLs. Accepted formats: * `https://*.s3.*.amazonaws.com/*` * `https://*.s3.amazonaws.com/*` * `https://s3.amazonaws.com/*` * `https://s3.*.amazonaws.com/*` Use either pre-signed (recommended) or public URLs. Accepted formats: * `https://*.r2.dev/*` * `https://*.r2.cloudflarestorage.com/*` Use either pre-signed (recommended) or public URLs. Accepted format: * `https://*.blob.core.windows.net/*` Use either pre-signed (recommended) or public URLs. Accepted format: * `https://storage.googleapis.com/*` Ensure the file can be downloaded directly from the URL. Accepted format: * `https://*.public.blob.vercel-storage.com/*` Use either pre-signed (recommended) or public URLs. Accepted format: * `https://*.supabase.co/*` Ensure the file can be downloaded directly from the URL. Accepted format: * `https://drive.google.com/*` Ensure the file can be downloaded directly from the URL. Accepted format: * `https://www.dropbox.com/*` Ensure the file can be downloaded directly from the URL. Accepted format: * `https://*.convex.cloud/api/storage/*` Ensure the file can be downloaded directly from the URL. Accepted format: * `https://*.cdn.bubble.io/*` Want support for another source? [Contact support](mailto:support@signatureapi.com). # Attestation and compliance Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/attestation Meet legal e-signature requirements for ESIGN, UETA, eIDAS, and country-specific standards like Mexico NOM-151 This page covers e-signature compliance. For [HIPAA compliance](/docs/trust/compliance/hipaa) or [SOC 2 compliance](/docs/trust/compliance/soc2), see their dedicated pages. SignatureAPI is legally binding and compliant with US e-signature regulations (ESIGN and UETA), the European eIDAS regulation (at the SES level), and similar laws around the world. Some countries have additional legal requirements. Use the `attestation` property to apply a country-specific standard to an envelope. ## Available attestations | Value | Description | | ----------- | --------------------------------------------------------------------------------------------------------- | | `none` | No attestation. This is the default and applies to most countries, including the US and EU member states. | | `mx_nom151` | Mexico NOM-151 compliance. See details below. | ## Mexico NOM-151 To enable NOM-151 attestations for your account, [contact support](https://signatureapi.com/support). [NOM-151](https://www.dof.gob.mx/normasOficiales/6499/seeco11_C/seeco11_C.html) defines the legal standards for data message preservation and document digitization in Mexico. When `attestation` is set to `mx_nom151`, a preservation certificate in ASN.1 format is attached to the deliverable. SignatureAPI also adds a verification link on the last page of the deliverable. Both the certificate and the deliverable can be verified using any ASN.1 signature verification tool. To use NOM-151, set `attestation` to `mx_nom151` when creating the envelope: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Contrato", "attestation": "mx_nom151", "documents": [ //... ], "recipients": [ //... ] } ``` NOM-151 attestation adds \$0.10 per completed envelope. # Envelope branding Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/branding Add your company logo and accent colors to signing ceremonies and recipient emails Add your company's branding to individual envelopes to customize the signing ceremony interface and the emails sent to recipients. Each envelope can have its own branding configuration. Branding applies to: * The signing ceremony interface recipients see. * Emails sent to recipients throughout the signing process (signing requests and completed document delivery). Branding does not apply to: * Internal notification emails sent to the account owner. * Deliverables (signed documents). See the [Visual examples](#visual-examples) section below for screenshots. ## Adding branding Include a `branding` object when creating an envelope: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "documents": [ //... ], "recipients": [ //... ], "branding": { "logo": "https://api.signatureapi.com/v1/uploads/upl_3jBYlxa9gv0fGLzFAnfwxe", "accent_color": "#9810fa", "email": { "footer": "**Disclaimer:** This email and its attachments may contain confidential information. If you are not the intended recipient, please delete it and notify the sender.", "logo_position": "left" } } } ``` ## Accent colors The `accent_color` property sets the color of buttons in emails and the signing ceremony. Specify the color as a hex code (for example, `#9810fa`). The accent color applies only to button styles. Other interactive elements such as text input fields, checkboxes, and signature boxes keep their default colors (blue for normal states, red for error states). ### Accessibility requirements The accent color must meet a contrast ratio of at least 4.5:1 against white, following [WCAG guidelines](https://www.w3.org/TR/WCAG21/). If the color does not meet this requirement, the API returns an error with a suggested compliant alternative. Test your color's contrast ratio using the [WebAIM Color Contrast Checker](https://webaim.org/resources/contrastchecker/) before submitting. ## Logos The `logo` property sets the image displayed in the header of emails and the signing ceremony. ### Preparing your logo 1. Upload your logo to the [Dashboard Library](https://dashboard.signatureapi.com/library). 2. Copy the resulting URL (it will look like `https://api.signatureapi.com/v1/uploads/upl_...`). 3. Use that URL in the `logo` property. Only files uploaded to your account's Library can be used as logos. Direct external URLs are not supported. ### Logo requirements * **Format:** PNG * **Height:** At least 160px to avoid pixelation on high-resolution displays * **File size:** Under 100KB * **Background:** Transparent works best, as logos appear against both white (emails) and gray (ceremony) backgrounds ## Email customization Use the `email` object within `branding` for additional email customization. ### Custom footer The `footer` property adds content at the bottom of all recipient emails, after SignatureAPI's standard footer. Use it for legal disclaimers, privacy notices, or contact information. The footer supports a subset of Markdown: `**bold**`, `*italic*`, and `\n\n` for paragraph breaks. ### Logo position The `logo_position` property controls the horizontal alignment of the logo in email headers. Accepted values are `left`, `center`, and `right`. The default is `left`. ## Visual examples The following screenshots show branding applied to a purple (`#9810fa`) envelope with a left-positioned logo. ### Signature request email Signature request email with custom branding applied ### Signing ceremony interface Signing ceremony interface with custom branding applied ### Completed document delivery email Document delivery email with custom branding applied # Cancel an envelope Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/cancel POST /v1/envelopes/{envelope_id}/cancel Cancel an in-progress envelope to permanently halt the signing process Cancels an envelope, immediately halting all signing activity. Once canceled, recipients can no longer access the signing ceremony. This action is irreversible and permanent. Only envelopes with status `in_progress` can be canceled. ## Path parameters The unique identifier of the envelope, in UUID format. ## Body parameters An optional explanation for why the envelope was canceled. This is for internal use only and is not shown to recipients. The reason is included in the `envelope.canceled` webhook event payload. Maximum 2,000 characters. ## Returns Returns a `200 OK` status code along with [an envelope object](/docs/api/resources/envelopes/object) on success, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // POST https://api.signatureapi.com/v1/envelopes/{envelope_id}/cancel // X-API-Key: key_test_... // Content-Type: application/json { "reason": "Price renegotiated by John D." } ``` ```json Response theme={null} // HTTP Status Code 200 { "id": "55072f0e-b919-4d69-89cd-e7e56af00530", "title": "Exploration Agreement", "status": "canceled", //... } ``` # Captures Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/captures Retrieve data entered by recipients during signing ceremonies through the API Some [place](/docs/api/resources/places/object) types allow recipients to enter data during the [ceremony](/docs/api/resources/ceremonies/object), such as [text input places](/docs/api/resources/places/text-input). The entered data is rendered in the signed document. Captures let you also access that data via the API. ## Defining captures Places that accept recipient input have a `capture_as` property. Set it to a key name to store the entered value on the envelope's `captures` object. Keys must be unique within the envelope. For example, this text input place asks a recipient to enter an 8-digit reference number: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "documents": [ { //... "places": [ { "key": "order_reference_number", "type": "text_input", "hint": "Your 8-digit reference code", "format": "/^[0-9]{8}$/", "recipient_key": "customer", "capture_as": "reference" } ] } ], "recipients": [ //... ], "title": "Order Confirmation" } ``` When the recipient completes the ceremony, the entered value is stored in the `captures` object on the envelope: ```json theme={null} // HTTP Status Code 200 { "id": "55072f0e-b919-4d69-89cd-e7e56af00530", //... "captures": { "reference": "11223344" } } ``` ## More examples ```json Multiple text captures theme={null} // Request places [ { "key": "ssn_last_four", "type": "text_input", "recipient_key": "applicant", "capture_as": "ssn_last_4", "format": "/^[0-9]{4}$/", "requirement": "required" }, { "key": "phone_number", "type": "text_input", "recipient_key": "applicant", "capture_as": "phone", "requirement": "required" } ] // Response captures { "captures": { "ssn_last_4": "1234", "phone": "555-123-4567" } } ``` ```json Checkbox capture theme={null} // Request places [ { "key": "accept_terms", "type": "checkbox", "recipient_key": "customer", "capture_as": "terms_accepted", "requirement": "required" }, { "key": "marketing_opt_in", "type": "checkbox", "recipient_key": "customer", "capture_as": "marketing_consent" } ] // Response captures { "captures": { "terms_accepted": true, "marketing_consent": false } } ``` ```json Dropdown capture theme={null} // Request places [ { "key": "state_selection", "type": "dropdown", "recipient_key": "applicant", "options": "us_states_2_letter_codes", "capture_as": "state", "requirement": "required" } ] // Response captures { "captures": { "state": "CA" } } ``` # Create an envelope Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/create POST /v1/envelopes Create a new envelope with documents and recipients to start the signing process Creates an [envelope](/docs/api/resources/envelopes/object) and starts the signing process. The envelope begins in `processing` status while documents are validated and recipients are queued for notification. It transitions to `in_progress` once recipients are notified. At minimum, provide a `title`, at least one `document`, and at least one `recipient`. All other properties are optional. ## Body parameters ### Required The title of the envelope, displayed to recipients in emails and the signing ceremony. Must be between 1 and 500 characters. For an internal label that is not shown to recipients, use the `label` property instead. The documents included in the envelope. An envelope can contain between 1 and 10 documents. Each document must be a publicly accessible PDF or DOCX file. Documents can include interactive places such as signature fields, text inputs, and checkboxes that recipients interact with during the signing ceremony. DOCX documents also support dynamic content via template data. A user-provided identifier for this document within the envelope. Must be unique within the envelope. Use the key to reference this document in other parts of the API. Only lowercase letters, numbers, and underscores are allowed. Must start with a letter. Maximum 32 characters. If not provided, a key is generated automatically. An optional display name for the document. When set, the title is shown to recipients during the signing ceremony and in deliverables. Defaults to `null` if not provided. Maximum 500 characters. The URL where the document or template file is located. The file must be publicly accessible. You can host files on Amazon S3, Google Cloud Storage, Azure Blob Storage, Cloudflare R2, and other services. You can also use the URL returned by the [Create Upload](/docs/api/resources/uploads/create) endpoint. Learn more about your options in [Document URL and Upload](/docs/api/resources/documents/url). The file format of the document. Determines which features are available. * `pdf` -- Standard PDF file. Supports places via placeholders or fixed positions. * `docx` -- Microsoft Word file. Supports template fields for dynamic content in addition to places. For PDF documents the format must be `pdf`. The key of the place to position. Must match one of the `key` values in the document's `places` array. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The page number where the place is positioned. Page numbering starts at 1. The vertical distance from the top edge of the page to the bottom-left corner of the place, measured in points (1 point = 1/72 of an inch). For example, `360` places the field 5 inches from the top edge. The horizontal distance from the left edge of the page to the bottom-left corner of the place, measured in points (1 point = 1/72 of an inch). For example, `72` places the field 1 inch from the left edge. Areas within a document where a recipient provides input (such as a signature or text) or where a value is displayed automatically (such as a completion date). Each place has a `type` that determines its behavior. A place must be positioned using either a `[[place_key]]` placeholder in the document text or an entry in the `fixed_positions` array. Learn more about [places](/docs/api/resources/places/object). A location where the recipient, identified by `recipient_key`, draws or types their signature. A single recipient can have multiple signature places across different pages of a document. Specifies the type of place. For a signature place, the value must be `signature`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the signature place in points. The width is calculated automatically using a 5:2 ratio based on this height. Must be between 20 and 60. Defaults to 60. A location where the recipient, identified by `recipient_key`, enters their initials. A single recipient can have multiple initials places across different pages of a document. Specifies the type of place. For an initials place, the value must be `initials`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the initials place in points. The width equals the height. Must be between 20 and 60. Defaults to 60. A read-only text value displayed at a specific location on the document. It is not interactive and does not require a recipient. Use this to pre-fill static information such as company names, reference numbers, or dates before the signing process begins. Specifies the type of place. For a text place, the value must be `text`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The text content to display on the document. This is a static value set when the envelope is created and cannot be changed by the recipient. Maximum length is 1000 characters. The font size in points. Must be between 1 and 144. The default is 12. The font color for this text place. Must be a six-digit hex color code with a leading `#`. Defaults to `#000000` (black). A location where the recipient, identified by `recipient_key`, types free-form text. Supports input validation, placeholder text, and tooltip hints. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a text input place, the value must be `text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. Defines the validation format for the user’s input. Accepted values: * `email` * `zipcode-us` * a custom regular expression, enclosed in `/`, for example: `/^[a-z0-9]{1,10}$/` Learn more in [Format Validation](/docs/api/resources/places/text-input#format-validation). The message displayed when the user’s input does not match the required format. Learn more in [Format Validation -> Adding a Custom Message](/docs/api/resources/places/text-input#adding-a-custom-message). The initial width of the text input field in points. The field may expand beyond this width during typing. Must be between 30 and 540. Defaults to 30. The font size in points. Must be between 6 and 12. Defaults to 12. A series of individual character boxes where the recipient, identified by `recipient_key`, enters text one character per box. Use this for structured data such as verification codes, ZIP codes, or the last four digits of an SSN. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a boxed text input place, the value must be `boxed_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The number of individual character boxes to display. Must be between 1 and 100. Each box accepts a single character from the recipient. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. A tooltip message displayed over the boxed text input field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). A placeholder message shown inside the first box during the signing ceremony to guide the recipient. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). Specifies whether the recipient must fill all boxes to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. The total width of the boxed input field in points. Must be between 30 and 540. The default is 30. The height of each individual box in points. The font size in points. Must be between 6 and 12. The default is 12. A location where the recipient, identified by `recipient_key`, enters text that spans multiple lines. Use this for comments, addresses, and longer descriptions. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a multi-line text input place, the value must be `multiline_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. The width of the multi-line text input place in points. Must be between 30 and 540. The default is 30. The number of lines for the multi-line text input field. Must be between 1 and 100. The line height in points. Must be greater than or equal to `font_size`. Must be between 6 and 72. The default is 12. The font size in points. Must be between 6 and 12. The default is 12. A location where the recipient, identified by `recipient_key`, checks or unchecks a box. Use `capture_as` to store the checkbox value in the envelope's captures. Specifies the type of place. For a checkbox place, the value must be `checkbox`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The symbol to display in the checkbox when it is checked. Available options are `check` and `xmark`. The default is `check`. Specifies whether the recipient must check this box to complete the signing ceremony. Possible values are `required` or `optional`. The default is `optional`. The height of the checkbox in points. The width equals the height. Must be between 8 and 40. Defaults to 20. A location where the recipient, identified by `recipient_key`, selects from a list of options. Options can be a custom list of label-value pairs or a predefined set such as country names or US state codes. Use `capture_as` to store the selected value in the envelope's captures. Specifies the type of place. For a dropdown place, the value must be `dropdown`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. Specifies the list of options available in the dropdown. You can provide either **custom options** or a **predefined option set**. **Custom options**: An array of objects, each with a `label` (displayed to the user) and an optional `value` (captured when selected). If `value` is omitted, the `label` is used as the value. ```json theme={null} "options": [ { "label": "Option A", "value": "a" }, { "label": "Option B", "value": "b" } ] ``` **Predefined options**: A string specifying a built-in option set: | Value | Description | | -------------------------------- | ----------------------------------------------- | | `world_countries_names` | Country names (e.g., "United States", "Canada") | | `world_countries_2_letter_codes` | ISO 3166-1 alpha-2 codes (e.g., "US", "CA") | | `world_countries_3_letter_codes` | ISO 3166-1 alpha-3 codes (e.g., "USA", "CAN") | | `world_countries_numeric_codes` | ISO 3166-1 numeric codes (e.g., "840", "124") | | `us_states_names` | US state names (e.g., "California", "Texas") | | `us_states_2_letter_codes` | US state codes (e.g., "CA", "TX") | Specifies the option that is pre-selected when the dropdown is displayed. The value is first matched against the `label` of each option. If no match is found, it is matched against the `value` of each option. If no match is found, a validation error is returned. Specifies the behavior of the dropdown during the signing ceremony. Possible values: * `auto` (default): Automatically selects the best behavior based on the number of options. Uses `select` for 10 or fewer options, and `combobox` for more than 10 options. * `select`: Displays a standard dropdown list. Best for short lists where users can quickly scan all options. * `combobox`: Displays a searchable dropdown with type-ahead filtering. Best for long lists where users need to search for their selection. Specifies whether the recipient must select an option to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. A placeholder message shown inside the dropdown field during the signing ceremony. Maximum length is 100 characters. Learn more in [Hints and Prompts](/docs/api/resources/places/dropdown#hints-and-prompts). A tooltip message displayed when the user hovers over or focuses on the dropdown field during the signing ceremony. Maximum length is 100 characters. Learn more in [Hints and Prompts](/docs/api/resources/places/dropdown#hints-and-prompts). A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The font size in points. Must be between 6 and 12. The default is 12. The width of the dropdown field in points. Must be between 30 and 540. The default is 30. Displays the date and time when the recipient, identified by `recipient_key`, completed their action on the envelope. Use `date_format` to control how the date is formatted. Specifies the type of place. For this kind of place, the value must be `recipient_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. The font size in points. Must be between 1 and 144. Defaults to 12. Displays the date and time when the envelope was completed. The envelope completes when all recipients have finished their actions. Use `date_format` to control how the date is formatted. Specifies the type of place. For this kind of place, the value must be `envelope_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. The font size in points. Must be between 1 and 144. Defaults to 12. Displays the name of the recipient, identified by `recipient_key`, at a specific location on the document. The value is inserted automatically. This place is read-only and does not require any action from the recipient. Specifies the type of place. For this kind of place, the value must be `recipient_name`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The font size in points. Must be between 1 and 144. Defaults to 12. Displays the email address of the recipient, identified by `recipient_key`, at a specific location on the document. The value is inserted automatically. This place is read-only and does not require any action from the recipient. Specifies the type of place. For this kind of place, the value must be `recipient_email`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The font size in points. Must be between 1 and 144. Defaults to 12. A user-provided identifier for this document within the envelope. Must be unique within the envelope. Use the key to reference this document in other parts of the API. Only lowercase letters, numbers, and underscores are allowed. Must start with a letter. Maximum 32 characters. If not provided, a key is generated automatically. An optional display name for the document. When set, the title is shown to recipients during the signing ceremony and in deliverables. Defaults to `null` if not provided. Maximum 500 characters. The URL where the document or template file is located. The file must be publicly accessible. You can host files on Amazon S3, Google Cloud Storage, Azure Blob Storage, Cloudflare R2, and other services. You can also use the URL returned by the [Create Upload](/docs/api/resources/uploads/create) endpoint. Learn more about your options in [Document URL and Upload](/docs/api/resources/documents/url). The file format of the document. Determines which features are available. * `pdf` -- Standard PDF file. Supports places via placeholders or fixed positions. * `docx` -- Microsoft Word file. Supports template fields for dynamic content in addition to places. For DOCX documents the format must be `docx`. Template data used to fill dynamic fields in a DOCX template. Each key corresponds to a `{{key}}` placeholder in the template file. Keys must be alphanumeric and at most 32 characters. Values can be strings, booleans, or nested objects. Nested keys map to dot-notation placeholders (for example, a key `person` with nested key `name` fills `{{person.name}}`). Defaults to `{}`. The key of the place to position. Must match one of the `key` values in the document's `places` array. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The page number where the place is positioned. Page numbering starts at 1. The vertical distance from the top edge of the page to the bottom-left corner of the place, measured in points (1 point = 1/72 of an inch). For example, `360` places the field 5 inches from the top edge. The horizontal distance from the left edge of the page to the bottom-left corner of the place, measured in points (1 point = 1/72 of an inch). For example, `72` places the field 1 inch from the left edge. Areas within a document where a recipient provides input (such as a signature or text) or where a value is displayed automatically (such as a completion date). Each place has a `type` that determines its behavior. A place must be positioned using either a `[[place_key]]` placeholder in the document text or an entry in the `fixed_positions` array. Learn more about [places](/docs/api/resources/places/object). A location where the recipient, identified by `recipient_key`, draws or types their signature. A single recipient can have multiple signature places across different pages of a document. Specifies the type of place. For a signature place, the value must be `signature`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the signature place in points. The width is calculated automatically using a 5:2 ratio based on this height. Must be between 20 and 60. Defaults to 60. A location where the recipient, identified by `recipient_key`, enters their initials. A single recipient can have multiple initials places across different pages of a document. Specifies the type of place. For an initials place, the value must be `initials`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the initials place in points. The width equals the height. Must be between 20 and 60. Defaults to 60. A read-only text value displayed at a specific location on the document. It is not interactive and does not require a recipient. Use this to pre-fill static information such as company names, reference numbers, or dates before the signing process begins. Specifies the type of place. For a text place, the value must be `text`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The text content to display on the document. This is a static value set when the envelope is created and cannot be changed by the recipient. Maximum length is 1000 characters. The font size in points. Must be between 1 and 144. The default is 12. The font color for this text place. Must be a six-digit hex color code with a leading `#`. Defaults to `#000000` (black). A location where the recipient, identified by `recipient_key`, types free-form text. Supports input validation, placeholder text, and tooltip hints. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a text input place, the value must be `text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. Defines the validation format for the user’s input. Accepted values: * `email` * `zipcode-us` * a custom regular expression, enclosed in `/`, for example: `/^[a-z0-9]{1,10}$/` Learn more in [Format Validation](/docs/api/resources/places/text-input#format-validation). The message displayed when the user’s input does not match the required format. Learn more in [Format Validation -> Adding a Custom Message](/docs/api/resources/places/text-input#adding-a-custom-message). The initial width of the text input field in points. The field may expand beyond this width during typing. Must be between 30 and 540. Defaults to 30. The font size in points. Must be between 6 and 12. Defaults to 12. A series of individual character boxes where the recipient, identified by `recipient_key`, enters text one character per box. Use this for structured data such as verification codes, ZIP codes, or the last four digits of an SSN. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a boxed text input place, the value must be `boxed_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The number of individual character boxes to display. Must be between 1 and 100. Each box accepts a single character from the recipient. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. A tooltip message displayed over the boxed text input field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). A placeholder message shown inside the first box during the signing ceremony to guide the recipient. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). Specifies whether the recipient must fill all boxes to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. The total width of the boxed input field in points. Must be between 30 and 540. The default is 30. The height of each individual box in points. The font size in points. Must be between 6 and 12. The default is 12. A location where the recipient, identified by `recipient_key`, enters text that spans multiple lines. Use this for comments, addresses, and longer descriptions. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a multi-line text input place, the value must be `multiline_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. The width of the multi-line text input place in points. Must be between 30 and 540. The default is 30. The number of lines for the multi-line text input field. Must be between 1 and 100. The line height in points. Must be greater than or equal to `font_size`. Must be between 6 and 72. The default is 12. The font size in points. Must be between 6 and 12. The default is 12. A location where the recipient, identified by `recipient_key`, checks or unchecks a box. Use `capture_as` to store the checkbox value in the envelope's captures. Specifies the type of place. For a checkbox place, the value must be `checkbox`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The symbol to display in the checkbox when it is checked. Available options are `check` and `xmark`. The default is `check`. Specifies whether the recipient must check this box to complete the signing ceremony. Possible values are `required` or `optional`. The default is `optional`. The height of the checkbox in points. The width equals the height. Must be between 8 and 40. Defaults to 20. A location where the recipient, identified by `recipient_key`, selects from a list of options. Options can be a custom list of label-value pairs or a predefined set such as country names or US state codes. Use `capture_as` to store the selected value in the envelope's captures. Specifies the type of place. For a dropdown place, the value must be `dropdown`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. Specifies the list of options available in the dropdown. You can provide either **custom options** or a **predefined option set**. **Custom options**: An array of objects, each with a `label` (displayed to the user) and an optional `value` (captured when selected). If `value` is omitted, the `label` is used as the value. ```json theme={null} "options": [ { "label": "Option A", "value": "a" }, { "label": "Option B", "value": "b" } ] ``` **Predefined options**: A string specifying a built-in option set: | Value | Description | | -------------------------------- | ----------------------------------------------- | | `world_countries_names` | Country names (e.g., "United States", "Canada") | | `world_countries_2_letter_codes` | ISO 3166-1 alpha-2 codes (e.g., "US", "CA") | | `world_countries_3_letter_codes` | ISO 3166-1 alpha-3 codes (e.g., "USA", "CAN") | | `world_countries_numeric_codes` | ISO 3166-1 numeric codes (e.g., "840", "124") | | `us_states_names` | US state names (e.g., "California", "Texas") | | `us_states_2_letter_codes` | US state codes (e.g., "CA", "TX") | Specifies the option that is pre-selected when the dropdown is displayed. The value is first matched against the `label` of each option. If no match is found, it is matched against the `value` of each option. If no match is found, a validation error is returned. Specifies the behavior of the dropdown during the signing ceremony. Possible values: * `auto` (default): Automatically selects the best behavior based on the number of options. Uses `select` for 10 or fewer options, and `combobox` for more than 10 options. * `select`: Displays a standard dropdown list. Best for short lists where users can quickly scan all options. * `combobox`: Displays a searchable dropdown with type-ahead filtering. Best for long lists where users need to search for their selection. Specifies whether the recipient must select an option to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. A placeholder message shown inside the dropdown field during the signing ceremony. Maximum length is 100 characters. Learn more in [Hints and Prompts](/docs/api/resources/places/dropdown#hints-and-prompts). A tooltip message displayed when the user hovers over or focuses on the dropdown field during the signing ceremony. Maximum length is 100 characters. Learn more in [Hints and Prompts](/docs/api/resources/places/dropdown#hints-and-prompts). A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The font size in points. Must be between 6 and 12. The default is 12. The width of the dropdown field in points. Must be between 30 and 540. The default is 30. Displays the date and time when the recipient, identified by `recipient_key`, completed their action on the envelope. Use `date_format` to control how the date is formatted. Specifies the type of place. For this kind of place, the value must be `recipient_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. The font size in points. Must be between 1 and 144. Defaults to 12. Displays the date and time when the envelope was completed. The envelope completes when all recipients have finished their actions. Use `date_format` to control how the date is formatted. Specifies the type of place. For this kind of place, the value must be `envelope_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. The font size in points. Must be between 1 and 144. Defaults to 12. Displays the name of the recipient, identified by `recipient_key`, at a specific location on the document. The value is inserted automatically. This place is read-only and does not require any action from the recipient. Specifies the type of place. For this kind of place, the value must be `recipient_name`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The font size in points. Must be between 1 and 144. Defaults to 12. Displays the email address of the recipient, identified by `recipient_key`, at a specific location on the document. The value is inserted automatically. This place is read-only and does not require any action from the recipient. Specifies the type of place. For this kind of place, the value must be `recipient_email`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The font size in points. Must be between 1 and 144. Defaults to 12. The recipients who participate in the envelope's signing process. An envelope can have between 1 and 10 recipients. Three types are supported: * `signer` -- Signs the documents. * `preparer` -- Fills in fields before signers receive the documents. * `approver` -- Reviews and approves the documents without signing. The type of the recipient. Determines what actions the recipient can perform during the ceremony. | Type | Description | | ---------- | -------------------------------------------------------------- | | `signer` | Signs documents. Every envelope must have at least one signer. | | `approver` | Reviews and approves documents without signing. | | `preparer` | Fills in document fields on behalf of another party. | For signers, the type must be `signer`. A unique identifier you assign to each recipient in the envelope. Use it to match recipients with the places they should interact with (such as signature fields) and to identify them in events and webhook notifications. The key must start with a lowercase letter. It can contain lowercase letters, numbers, and underscores. Maximum 32 characters. It must be unique within the envelope. The full name of the recipient. Appears in invitation emails and is pre-filled for typed signatures. The email address of the recipient. Used to send invitation emails when `delivery_type` is `email`. Configuration for the first ceremony to create for the recipient. If not provided, a ceremony with `email_link` authentication is created by default.
With **email link authentication**, the recipient receives an email with a direct link to the ceremony. Clicking the link authenticates the recipient and opens the signing session.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email link authentication, set `type` to `email_link`. A custom subject line for the invitation email sent to this recipient. When not set, the subject defaults to the [envelope title](/docs/api/resources/envelopes/object#param-title). Maximum 500 characters. A custom message body for the invitation email sent to this recipient. When not set, the message defaults to the [envelope message](/docs/api/resources/envelopes/object#param-message). Supports Markdown formatting: `**bold**`, `*italic*`, and `\n\n` for paragraph breaks. Maximum 2000 characters.
With **email code authentication**, the recipient receives an email from SignatureAPI containing a 9-digit code. The recipient must enter this code to authenticate and access the ceremony.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email code authentication, set `type` to `email_code`.
With **custom authentication**, your application authenticates the recipient. SignatureAPI provides a ceremony URL that you share or embed in your application to give the recipient access.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For custom authentication, set `type` to `custom`. The name of your company or application that authenticated the recipient. This value appears in the envelope audit log as the authentication provider. Key-value pairs with metadata about the authentication event, such as timestamps, session IDs, and user identifiers. These values appear in the envelope audit log. The values in `data` must be sufficient to verify how the recipient was authenticated. You must retain all records needed to prove the recipient's authentication, such as session information. In cases such as legal proceedings, you may need to provide these records to confirm identity. Review our [Terms & Conditions](https://signatureapi.com/terms) for details.
An HTTPS URL to redirect the recipient to after the ceremony finishes. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The delay in seconds before the ceremony redirects to `redirect_url` (standalone ceremonies) or emits completion events (embedded ceremonies). Defaults to `3`. Allowed range: `0` to `20`. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The format of the ceremony URL. Available options: * `standard` (default): Full-length URL. Works for most use cases. * `short`: Shortened URL. Use this when sharing through space-constrained channels such as SMS or push notifications. Origins allowed to embed this ceremony in an iframe. These values set the `frame-ancestors` directive in the ceremony's Content Security Policy (CSP) header. Sources typically take the form of a scheme and host (for example, `https://app.example.com`). Wildcards are supported (for example, `https://*.example.com`). For all available options, see the [frame-ancestors documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors#sources). Defaults to an empty list (`[]`), which means embedding is not allowed. To allow embedding from all origins (not recommended for production), use `["*"]`. Only the origin (scheme and host) is used. Paths are ignored.
Controls whether the completed deliverable is automatically emailed to this recipient. | Value | Description | | ------- | ----------------------------------------------------------------------------------------------------------- | | `email` | The completed deliverable is delivered to this recipient by email. This is the default for signers. | | `none` | The completed deliverable is not emailed. Your application is responsible for distributing the deliverable. | The signature methods available to the signer. The first item in the array is shown as the default. | Option | Description | | ------- | ----------------------------------------------------------------------------------- | | `typed` | The signer types their name. It is pre-filled from the recipient's `name` property. | | `drawn` | The signer draws their signature using a mouse, stylus, or touchscreen. | If not specified, both `typed` and `drawn` are available, with `typed` shown first.
How the ceremony is created for the recipient. Available options are `automatic` and `manual`. The default is `automatic`. This property is deprecated. Use the `ceremony` object on the recipient when creating an envelope to control ceremony creation. This property will continue to be supported for backwards compatibility.
### Signing options Controls the order in which recipients receive and act on the envelope. * `sequential` -- Recipients act one at a time, in the order listed. Each recipient must complete before the next is notified. This is the default. * `parallel` -- All recipients are notified at the same time and can act in any order. Learn more about [recipient routing](/docs/api/resources/envelopes/routing). Configuration for the deliverable generated when the envelope is completed. The deliverable is sent to all recipients via email. To prevent automatic delivery to a recipient, set that recipient's `delivery_type` to `none`. If omitted, a `standard` deliverable is generated automatically. The standard deliverable includes an audit log. To get signed documents without an audit log, use the [simple deliverable](/docs/api/resources/deliverables/simple) instead. A user-provided name for this deliverable. Use this to identify deliverables when an envelope has more than one. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Between 1 and 32 characters. The type of the deliverable. * `standard`: Includes the signed documents and an audit log with a certificate of completion. This is the default. * `simple`: Includes the signed documents only, without an audit log. For standard deliverables, the type is `standard`. The language for system-generated text in the audit log, including labels and the certificate of completion. Does not affect the content of the signed documents. Supported values: `en` (English), `es` (Spanish), `fr` (French), `it` (Italian), `pt` (Portuguese), `de` (German), `zh` (Chinese Simplified), `hu` (Hungarian). Defaults to the envelope language. The timezone used for timestamps in the audit log. Must be a valid IANA Time Zone Database identifier (e.g., `America/New_York`, `Europe/London`). Does not affect timestamps inside the signed documents. Defaults to the envelope timezone. The format for timestamps in the audit log. Uses MomentJS format tokens (e.g., `MM/DD/YYYY HH:mm:ss`). Does not affect timestamps inside the signed documents. Defaults to the envelope timestamp format. The keys of the documents to include in the deliverable. By default, all documents in the envelope are included. Use this to create a deliverable with only a subset of documents. For example, generate separate deliverables for different recipients. Accepts between 1 and 10 document keys. The password used to encrypt the deliverable. Recipients must enter this password to access the downloaded file. Password requirements: * Between 4 and 32 characters * Letters and numbers only (no special characters or spaces) When returned in API responses, the password value is masked for security (displayed as `********`). Password protection is available upon request. [Contact support](https://signatureapi.com/support) to enable this feature. The simple deliverable does not include an audit log. To get signed documents with an audit log, use the [standard deliverable](/docs/api/resources/deliverables/standard) instead. A user-provided name for this deliverable. Use this to identify deliverables when an envelope has more than one. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Between 1 and 32 characters. The type of the deliverable. * `standard`: Includes the signed documents and an audit log with a certificate of completion. This is the default. * `simple`: Includes the signed documents only, without an audit log. For simple deliverables, the type is `simple`. The keys of the documents to include in the deliverable. By default, all documents in the envelope are included. Use this to create a deliverable with only a subset of documents. For example, generate separate deliverables for different recipients. Accepts between 1 and 10 document keys. The password used to encrypt the deliverable. Recipients must enter this password to access the downloaded file. Password requirements: * Between 4 and 32 characters * Letters and numbers only (no special characters or spaces) When returned in API responses, the password value is masked for security (displayed as `********`). Password protection is available upon request. [Contact support](https://signatureapi.com/support) to enable this feature. The regulatory attestation applied to the envelope. Use this to meet country-specific e-signature requirements. * `none` -- No attestation. This is the default and covers most countries, including the US and EU member states. * `mx_nom151` -- Mexico NOM-151 compliance. Attaches a preservation certificate to the deliverable. For more information, see [Attestation](/docs/api/resources/envelopes/attestation). ### Recipient experience A custom message included in the signing request emails sent to recipients. Use it to provide context about what is being signed. Supports up to 2,000 characters. Accepts a subset of Markdown: * `**bold**` for bold text * `*italic*` for italic text * `\n\n` for paragraph breaks Defaults to `null`. The language used for the signing ceremony, recipient emails, and the audit log in deliverables. Supported values: `en` (English), `es` (Spanish), `fr` (French), `it` (Italian), `pt` (Portuguese), `de` (German), `zh` (Chinese Simplified), `hu` (Hungarian). If not specified, the account's default language is used. Learn more about [language](/docs/api/resources/envelopes/language). The time zone applied to timestamps in the deliverable's audit log. Must be a valid IANA Time Zone Database identifier (for example, `America/New_York` or `Europe/London`). If not specified, the account's default time zone is used. Learn more about [time zones](/docs/api/resources/envelopes/timezone). The date and time format used for timestamps in the deliverable's audit log. Uses MomentJS format tokens (for example, `MM/DD/YYYY HH:mm:ss`). If not specified, the account's default timestamp format is used. Learn more about [timestamp formats](/docs/api/resources/envelopes/timestamp-format). The sender of the envelope. Sender information appears in emails sent to recipients, identifying who initiated the signing request. If omitted, the account's default sender name and email are used. The name of the sender, displayed to recipients in emails and the signing ceremony. Maximum 500 characters. The email address of the sender, shown to recipients for reference. Maximum 320 characters. The organization name of the sender, displayed to recipients alongside the sender's name and email. Defaults to `null`. Maximum 500 characters. Customizes the visual appearance of the signing ceremony and recipient emails. Branding does not affect internal notifications or signed documents. Learn more about [branding](/docs/api/resources/envelopes/branding). The URL of the logo image displayed in the header of emails and the signing ceremony. Must be a PNG file uploaded to the Library. Defaults to `null`. Only files uploaded to your account's Library are accepted. Direct external URLs are not supported. The accent color applied to buttons in emails and the signing ceremony. Specified as a hex color code (for example, `#2463eb`). Defaults to `#2463eb`. The color must have a contrast ratio of at least 4.5:1 against white, following [WCAG guidelines](https://www.w3.org/TR/WCAG21/). If the color does not meet this requirement, the API returns an error with a suggested compliant alternative. Additional customization for emails sent to recipients, including footer text and logo alignment. A custom footer included at the bottom of all recipient emails for this envelope, after SignatureAPI's standard footer content. Use it for disclaimers, privacy notices, or contact information. Defaults to `null`. Supports a subset of Markdown: `**bold**`, `*italic*`, and `\n\n` for paragraph breaks. Maximum 10,000 characters. The horizontal alignment of the logo in recipient emails. Accepted values are `left`, `center`, and `right`. Defaults to `left`. ### Organization A custom label for internal identification. Labels are not shown to recipients. Unlike `title`, which recipients see, the label is for your team's use only. It can be updated at any time via the Update Envelope endpoint. Maximum 500 characters. Defaults to `null`. An array of up to 10 tags used to classify the envelope and filter webhook notifications. Each topic must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters per topic. Learn more about [topics](/docs/api/resources/envelopes/topics). A set of up to 10 custom key-value pairs for attaching internal reference data to the envelope. Use metadata to link envelopes to records in your own systems. Keys: up to 32 characters (letters, digits, and underscores). Values: up to 1,000 characters. Do not store sensitive information as metadata. Learn more about [metadata](/docs/api/resources/envelopes/metadata). ## Returns Returns a `201 Created` status code along with [an envelope object](/docs/api/resources/envelopes/object) on success, or an [error](/docs/api/errors) otherwise. ```json Request (minimal) theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "message": "Please review the privacy policy and provide your signature.", "documents": [ { "url": "https://pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/privacy-placeholder.pdf", "format": "pdf", "places": [ { "key": "signer_signs_here", "type": "signature", "recipient_key": "visitor" } ] } ], "recipients": [ { "type": "signer", "key": "visitor", "name": "John Doe", "email": "john@example.com" } ] } ``` ```json Request (full) theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Exploration Agreement", "label": "Exploration Agreement for Order Ref. 25005", "routing": "sequential", "message": "Please review the agreement and provide your signature.", "topics": [ "sales", "project_blue" ], "metadata": { "customer_ref": "x9550501", "account_annual_revenue": "$4,500,000" }, "branding": { "logo": "https://api.signatureapi.com/v1/uploads/upl_3jBYlxa9gv0fGLzFAnfwxe", "accent_color": "#9810fa", "email": { "footer": "**Disclaimer:** This email and its attachments may contain confidential information. If you are not the intended recipient, please delete it and notify the sender.", "logo_position": "left" } }, "documents": [ { "title": "Exploration Agreement", "url": "https://pub-e5051420e98a4fdfb3fd42a62fbf06fa.r2.dev/dummy.docx", "format": "docx", "data": { "date": "December 31st, 2025", "showAlert": true, "serviceProvider": { "name": "Jane Smith", "organization": "ACME Global, Inc." }, "client": { "name": "Michael J. Miller", "organization": "Miller Industries" } }, "places": [ { "key": "provider_signs_here", "type": "signature", "recipient_key": "service_provider", "height": 60 }, { "key": "client_signs_here", "type": "signature", "recipient_key": "client", "height": 60 } ] } ], "recipients": [ { "type": "signer", "key": "service_provider", "name": "Jane Smith", "email": "jane@example.com", "signature_options": ["typed", "drawn"], "delivery_type": "email", "ceremony": { "authentication": [ { "type": "email_code" } ], "redirect_url": "https://example.com/after-signing", "embeddable_in": [], "url_variant": "short" } }, { "type": "signer", "key": "client", "name": "Michael J. Miller", "email": "michael@example.com", "signature_options": ["drawn"], "delivery_type": "email", "ceremony": { "authentication": [ { "type": "custom", "provider": "My App", "data": { "session_id": "1234567890", "user_id": "user123" } } ], "redirect_url": null, "embeddable_in": [], "url_variant": "standard" } } ], "deliverable": { "type": "standard", "language": "en", "timezone": "UTC", "timestamp_format": "MM/DD/YYYY HH:mm:ss" } } ``` ```json Response theme={null} // HTTP Status Code 201 { "id": "55072f0e-b919-4d69-89cd-e7e56af00530", "title": "Exploration Agreement", "label": "Exploration Agreement for Order Ref. 25005", "message": "Please review the agreement and provide your signature.", "topics": [ "sales", "project_blue" ], "metadata": { "customer_ref": "x9550501", "account_annual_revenue": "$4,500,000" }, "status": "processing", "mode": "live", "routing": "sequential", "language": "en", "timezone": "UTC", "timestamp_format": "MM/DD/YYYY HH:mm:ss", "attestation": "none", "branding": { "logo": "https://api.signatureapi.com/v1/uploads/upl_3jBYlxa9gv0fGLzFAnfwxe", "accent_color": "#9810fa", "email": { "from": "noreply@signatureapi.com", "footer": "**Disclaimer:** This email and its attachments may contain confidential information. If you are not the intended recipient, please delete it and notify the sender.", "logo_position": "left" } }, "sender": { "name": "Jennifer Lee", "email": "jennifer@example.com", "organization": "Acme Enterprises" }, "documents": [ { "id": "doc_3jBYlxa9gv0fGLzFAnfwxe", "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "title": "Exploration Agreement", "page_count": 2, "url": "https://pub-e5051420e98a4fdfb3fd42a62fbf06fa.r2.dev/dummy.docx", "format": "docx", "data": { "date": "December 31st, 2025", "showAlert": true, "serviceProvider": { "name": "Jane Smith", "organization": "ACME Global, Inc." }, "client": { "name": "Michael J. Miller", "organization": "Miller Industries" } }, "places": [ { "key": "provider_signs_here", "type": "signature", "recipient_key": "service_provider", "height": 60 }, { "key": "client_signs_here", "type": "signature", "recipient_key": "client", "height": 60 } ] } ], "recipients": [ { "id": "re_26w2VVV5JVm4j459TY5BNM", "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "type": "signer", "key": "service_provider", "name": "Jane Smith", "email": "jane@example.com", "status": "pending", "ceremony": { "authentication": [ { "type": "email_link", "subject_override": null, "message_override": null } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": null }, "delivery_type": "email", "ceremony_creation": "automatic", "signature_options": ["typed", "drawn"], "completed_at": null, "status_updated_at": "2025-12-31T12:00:01.000Z" }, { "id": "re_38UVwrWdCqX5kqeKFJUTtf", "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "type": "signer", "key": "client", "name": "Michael J. Miller", "email": "michael@example.com", "status": "pending", "ceremony": { "authentication": [ { "type": "email_link", "subject_override": null, "message_override": null } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": null }, "delivery_type": "email", "ceremony_creation": "automatic", "signature_options": ["drawn"], "completed_at": null, "status_updated_at": "2025-12-31T12:00:01.000Z" } ], "deliverable": { "id": "del_1T7If8GgrTOf7zBVPaJf2e", "name": null, "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "type": "standard", "status": "pending", "url": null, "language": "en", "timezone": "UTC", "timestamp_format": "MM/DD/YYYY HH:mm:ss", "included_documents": null, "password": null, "created_at": "2025-12-31T12:00:00.000Z", "generated_at": null }, "captures": {}, "snapshot_url": null, "created_at": "2025-12-31T12:00:00.000Z", "completed_at": null } ``` # Delete an envelope Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/delete DELETE /v1/envelopes/{envelope_id} Permanently delete a canceled, failed, or completed envelope Permanently deletes an envelope. The envelope immediately becomes inaccessible through the API. Only envelopes with status `canceled`, `completed`, or `failed` can be deleted. To delete an envelope in `processing` or `in_progress` status, [cancel it first](/docs/api/resources/envelopes/cancel). Deleted envelopes can be recovered via a support request within 14 days. After 14 days, the data is permanently removed. ## Path parameters The unique identifier of the envelope, in UUID format. ## Returns Returns a `204 No Content` status code on success, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // DELETE https://api.signatureapi.com/v1/envelopes/{envelope_id} // X-API-Key: key_test_... ``` # Retrieve an envelope Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/get GET /v1/envelopes/{envelope_id} Retrieve the full details of an existing envelope Retrieves the full details of an envelope, including its documents, recipients, deliverable, sender information, and captures. Use this endpoint to check the current status of an envelope, retrieve recipient ceremony URLs, or access the deliverable download URL after completion. All properties are returned regardless of the envelope's current status. Properties not yet available (such as `completed_at` for an in-progress envelope) are returned as `null`. ## Path parameters The unique identifier of the envelope, in UUID format. ## Returns Returns a `200 OK` status code along with [an envelope object](/docs/api/resources/envelopes/object) on success, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // GET https://api.signatureapi.com/v1/envelopes/{envelope_id} // X-API-Key: key_test_... ``` ```json Response theme={null} // HTTP Status Code 200 { "id": "55072f0e-b919-4d69-89cd-e7e56af00530", "title": "Exploration Agreement", "label": "Exploration Agreement for Order Ref. 25005", "message": "Please review the agreement and provide your signature.", "status": "completed", "mode": "live", "routing": "sequential", "language": "en", "timezone": "America/New_York", "timestamp_format": "MM/DD/YYYY HH:mm:ss", "attestation": "none", "branding": { "logo": null, "accent_color": "#2463eb", "email": { "from": "noreply@signatureapi.com", "footer": null, "logo_position": "left" } }, "sender": { "name": "Jennifer Lee", "email": "jennifer@example.com", "organization": "Acme Enterprises" }, "topics": [ "sales", "project_blue" ], "metadata": { "customer_ref": "x9550501", "account_annual_revenue": "$4,500,000" }, "documents": [ { "id": "doc_3jBYlxa9gv0fGLzFAnfwxe", "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "title": "Exploration Agreement", "page_count": 2, "url": "https://pub-e5051420e98a4fdfb3fd42a62fbf06fa.r2.dev/dummy.docx", "format": "docx", "data": { "date": "December 31st, 2025", "showAlert": true, "serviceProvider": { "name": "Jane Smith", "organization": "ACME Global, Inc." }, "client": { "name": "Michael J. Miller", "organization": "Miller Industries" } }, "places": [ { "key": "provider_signs_here", "type": "signature", "recipient_key": "service_provider" }, { "key": "client_signs_here", "type": "signature", "recipient_key": "client" } ] } ], "recipients": [ { "id": "re_26w2VVV5JVm4j459TY5BNM", "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "type": "signer", "key": "service_provider", "name": "Jane Smith", "email": "jane@example.com", "status": "completed", "ceremony": { "authentication": [ { "type": "email_link", "subject_override": null, "message_override": null } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": null }, "delivery_type": "email", "ceremony_creation": "automatic", "signature_options": ["typed", "drawn"], "completed_at": "2025-12-31T14:00:00.000Z", "status_updated_at": "2025-12-31T14:00:00.000Z" }, { "id": "re_38UVwrWdCqX5kqeKFJUTtf", "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "type": "signer", "key": "client", "name": "Michael J. Miller", "email": "michael@example.com", "status": "completed", "ceremony": { "authentication": [ { "type": "email_link", "subject_override": null, "message_override": null } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": null }, "delivery_type": "email", "ceremony_creation": "automatic", "signature_options": ["typed", "drawn"], "completed_at": "2025-12-31T15:00:00.000Z", "status_updated_at": "2025-12-31T15:00:00.000Z" } ], "deliverable": { "id": "del_1T7If8GgrTOf7zBVPaJf2e", "name": null, "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "type": "standard", "status": "generated", "url": "https://s3.us-east-2.amazonaws.com/signatureapi-vault-dev/envelopes/55072f0e...", "language": "en", "timezone": "America/New_York", "timestamp_format": "MM/DD/YYYY HH:mm:ss", "included_documents": null, "password": null, "created_at": "2025-12-31T12:00:00.000Z", "generated_at": "2025-12-31T15:00:05.000Z" }, "captures": {}, "snapshot_url": null, "created_at": "2025-12-31T12:00:00.000Z", "completed_at": "2025-12-31T15:00:00.000Z" } ``` # Language Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/language Set the language for signing interfaces and recipient emails with supported language codes The `language` property sets the language used for the signing ceremony, recipient emails, and the audit log in deliverables. Set it to one of the supported language codes when creating an envelope. If not specified, the account's default language is used. Set your account default in the Settings section of the dashboard. ## Supported languages | Language | Code | | -------------------- | ---- | | English | `en` | | Spanish | `es` | | French | `fr` | | German | `de` | | Italian | `it` | | Portuguese (Brazil) | `pt` | | Chinese (Simplified) | `zh` | | Hungarian | `hu` | More languages are coming soon. To ask about a specific language, [contact support](https://signatureapi.com/support). ## Setting the language for an envelope ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Acuerdo de Ejemplo", "language": "es", "documents": [ //... ], "recipients": [ //... ] } ``` The selected language appears in: * Signing request and completion emails. * Buttons, messages, and click-through agreements in the ceremony interface. * The audit log in deliverables. ## Non-Latin scripts in documents The `language` property controls the signing interface and emails, not the document content. If your documents contain non-Latin scripts (Arabic, Hebrew, Chinese, etc.), the text renders correctly as long as the fonts are embedded in the file. * **PDF**: Fonts must be embedded in the PDF. Most PDF generators do this by default. If text appears garbled, re-export the PDF with fonts embedded. * **DOCX**: Embed fonts in the Word file before uploading. In Microsoft Word, go to **File > Options > Save** and check **Embed fonts in the file**. This ensures the document renders correctly regardless of what fonts are installed on the server. DOCX files created with Google Docs or LibreOffice may not embed fonts correctly. Use Microsoft Word for documents with non-Latin scripts. # Envelope lifecycle Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/lifecycle Track envelope status through processing, in_progress, completed, failed, and canceled states The `status` property indicates the envelope's current stage in the signing process. | Status | Description | | ------------- | ----------------------------------------------------------------------------------------------------------------- | | `processing` | The envelope is being prepared. Documents are validated and recipients are queued for notification. | | `in_progress` | The envelope has been sent to recipients and is waiting for all participants to complete their part. | | `completed` | All recipients have completed the envelope. A deliverable has been generated. | | `failed` | An internal error occurred during processing. Failures are rare and trigger automatic alerts to the support team. | | `canceled` | The signing process was stopped before completion. | The typical progression is `processing` to `in_progress` to `completed`. An envelope can transition to `failed` from `processing`, or to `canceled` from `in_progress`. To cancel an envelope in `in_progress` status, use the [Cancel Envelope](/docs/api/resources/envelopes/cancel) endpoint. Envelopes in `processing` status cannot be canceled directly. They must first transition to `in_progress`. # List envelopes Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/list GET /v1/envelopes Returns a paginated list of all envelopes in your account Returns a paginated list of envelopes in the current account, sorted by creation date with the most recent envelopes first. Use the `status` parameter to filter by envelope status and the `topic` parameter to filter by topic tag. ## Query parameters Filter the list to envelopes with this status. Accepted values: `processing`, `in_progress`, `completed`, `failed`, and `canceled`. Filter the list to envelopes with this [topic](/docs/api/resources/envelopes/topics) tag. The maximum number of objects to return in the response, up to 20. The default is 20. For certain use cases we can increase the limit. Please contact [support](mailto:support@signatureapi.com). ## Returns Returns a `200 OK` status code along with a [paginated](/docs/api/pagination) list of [envelope objects](/docs/api/resources/envelopes/object) on success, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // GET https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... ``` ```json Response theme={null} // HTTP Status Code 200 { "links": { "next": "https://api.signatureapi.com/v1/envelopes?cursor=seq_0thJdKRhN4&limit=20", "previous": null }, "data": [ { "id": "55072f0e-b919-4d69-89cd-e7e56af00530", "title": "Exploration Agreement", //... }, { "id": "a4ef2b1c-d834-4a72-bc19-e7e56af00531", "title": "Service Contract", //... }, { "id": "b8c3f901-e219-4b63-ad27-e7e56af00532", "title": "Non-Disclosure Agreement", //... } ] } ``` # Envelope metadata Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/metadata Attach custom key-value data to envelopes for internal reference IDs and tracking The `metadata` property lets you attach custom key-value pairs to an envelope. Use it to link envelopes to records in your own systems, such as internal reference IDs, account numbers, or transaction identifiers. Metadata is included in all API responses that return an envelope and in all [webhook](/docs/api/webhooks) payloads in the `data.envelope_metadata` field. Do not store sensitive information (such as bank account numbers or card details) as metadata. ## Limits * Up to 10 key-value pairs per envelope. * Keys: up to 32 characters (letters, digits, and underscores). * Values: up to 1,000 characters. ## Using metadata Add a `metadata` object when creating an envelope: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Customer Agreement", "metadata": { "user_id": "100200", "contract_number": "CNT-2026-001" }, "documents": [ //... ], "recipients": [ //... ] } ``` When a recipient signs, SignatureAPI sends a `recipient.completed` webhook that includes your metadata: ```json theme={null} { "id": "evt_4p2oouvNvjp1I9ckgqycH2", "type": "recipient.completed", "timestamp": "2025-12-31T15:00:01.999Z", "data": { "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "user_id": "100200", "contract_number": "CNT-2026-001" } //... } } ``` Use the metadata in webhook handlers to update records, trigger workflows, or route notifications in your system. ## Examples ```json Multiple keys theme={null} { "title": "Investment Agreement", "metadata": { "deal_id": "DEAL-2026-0042", "investor_id": "INV-88421", "round": "Series A", "amount": "500000" } //... } ``` ```json Webhook correlation theme={null} { "title": "Loan Application", "metadata": { "application_id": "APP-78542", "correlation_id": "corr_a1b2c3d4", "source_system": "loan-origination" } //... } ``` ```json Customer reference theme={null} { "title": "Service Agreement", "metadata": { "customer_id": "CUST-12345", "contract_number": "CNT-2026-001", "sales_rep": "jsmith" } //... } ``` ## Metadata vs. topics Use [topics](/docs/api/resources/envelopes/topics) to categorize and filter envelopes within SignatureAPI. Use metadata to store information that connects envelopes to records in your own systems. # Envelope Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/object The envelope object and all its properties An envelope is a container that holds [documents](/docs/api/resources/documents/object) to be sent to [recipients](/docs/api/resources/recipients/object) for signature. It defines and manages the signing process for those documents. When an envelope is [completed](/docs/api/resources/envelopes/lifecycle), a [deliverable](/docs/api/resources/deliverables/object) is generated and sent to the recipients. ## Relationships An envelope: * Has one or more [recipients](/docs/api/resources/recipients/object) (signers, approvers, or preparers) * Has one or more [documents](/docs/api/resources/documents/object) (PDF or DOCX format) * Has one or more [deliverables](/docs/api/resources/deliverables/object) generated upon completion ## Attributes The unique identifier of the envelope, in UUID format. The title of the envelope, displayed to recipients in emails and the signing ceremony. Must be between 1 and 500 characters. For an internal label that is not shown to recipients, use the `label` property instead. A custom label for internal identification. Labels are not shown to recipients. Unlike `title`, which recipients see, the label is for your team's use only. It can be updated at any time via the Update Envelope endpoint. Maximum 500 characters. Defaults to `null`. A custom message included in the signing request emails sent to recipients. Use it to provide context about what is being signed. Supports up to 2,000 characters. Accepts a subset of Markdown: * `**bold**` for bold text * `*italic*` for italic text * `\n\n` for paragraph breaks Defaults to `null`. The current status of the envelope in its lifecycle. * `processing` -- The envelope is being prepared. Documents are validated and recipients are notified. * `in_progress` -- The envelope has been sent to recipients and is waiting for all participants to complete. * `completed` -- All recipients have completed their part. A deliverable has been generated. * `failed` -- An internal error occurred during processing. Failures are rare and trigger automatic alerts. * `canceled` -- The signing process was intentionally stopped before completion. The typical progression is `processing` → `in_progress` → `completed`. Learn more about the [envelope lifecycle](/docs/api/resources/envelopes/lifecycle). The mode of the envelope, which determines its legal status and billing. * `live` -- Legally binding and billable. Created when using a live API key. * `test` -- Not legally binding and free of charge. Created when using a test API key. The mode is set automatically based on the API key used to create the envelope and cannot be changed afterward. Customizes the visual appearance of the signing ceremony and recipient emails. Branding does not affect internal notifications or signed documents. Learn more about [branding](/docs/api/resources/envelopes/branding). The URL of the logo image displayed in the header of emails and the signing ceremony. Must be a PNG file uploaded to the Library. Defaults to `null`. Only files uploaded to your account's Library are accepted. Direct external URLs are not supported. The accent color applied to buttons in emails and the signing ceremony. Specified as a hex color code (for example, `#2463eb`). Defaults to `#2463eb`. The color must have a contrast ratio of at least 4.5:1 against white, following [WCAG guidelines](https://www.w3.org/TR/WCAG21/). If the color does not meet this requirement, the API returns an error with a suggested compliant alternative. Additional customization for emails sent to recipients, including footer text and logo alignment. The email address shown in the "From" field of emails sent to recipients. Defaults to `noreply@signatureapi.com`. A custom footer included at the bottom of all recipient emails for this envelope, after SignatureAPI's standard footer content. Use it for disclaimers, privacy notices, or contact information. Defaults to `null`. Supports a subset of Markdown: `**bold**`, `*italic*`, and `\n\n` for paragraph breaks. Maximum 10,000 characters. The horizontal alignment of the logo in recipient emails. Accepted values are `left`, `center`, and `right`. Defaults to `left`. Controls the order in which recipients receive and act on the envelope. * `sequential` -- Recipients act one at a time, in the order listed. Each recipient must complete before the next is notified. This is the default. * `parallel` -- All recipients are notified at the same time and can act in any order. Learn more about [recipient routing](/docs/api/resources/envelopes/routing). The language used for the signing ceremony, recipient emails, and the audit log in deliverables. Supported values: `en` (English), `es` (Spanish), `fr` (French), `it` (Italian), `pt` (Portuguese), `de` (German), `zh` (Chinese Simplified), `hu` (Hungarian). If not specified, the account's default language is used. Learn more about [language](/docs/api/resources/envelopes/language). The time zone applied to timestamps in the deliverable's audit log. Must be a valid IANA Time Zone Database identifier (for example, `America/New_York` or `Europe/London`). If not specified, the account's default time zone is used. Learn more about [time zones](/docs/api/resources/envelopes/timezone). The date and time format used for timestamps in the deliverable's audit log. Uses MomentJS format tokens (for example, `MM/DD/YYYY HH:mm:ss`). If not specified, the account's default timestamp format is used. Learn more about [timestamp formats](/docs/api/resources/envelopes/timestamp-format). The sender of the envelope. Sender information appears in emails sent to recipients, identifying who initiated the signing request. If omitted, the account's default sender name and email are used. The name of the sender, displayed to recipients in emails and the signing ceremony. Maximum 500 characters. The email address of the sender, shown to recipients for reference. Maximum 320 characters. The organization name of the sender, displayed to recipients alongside the sender's name and email. Defaults to `null`. Maximum 500 characters. An array of up to 10 tags used to classify the envelope and filter webhook notifications. Each topic must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters per topic. Learn more about [topics](/docs/api/resources/envelopes/topics). A set of up to 10 custom key-value pairs for attaching internal reference data to the envelope. Use metadata to link envelopes to records in your own systems. Keys: up to 32 characters (letters, digits, and underscores). Values: up to 1,000 characters. Do not store sensitive information as metadata. Learn more about [metadata](/docs/api/resources/envelopes/metadata). The documents included in the envelope. An envelope can contain between 1 and 10 documents. Each document must be a publicly accessible PDF or DOCX file. Documents can include interactive places such as signature fields, text inputs, and checkboxes that recipients interact with during the signing ceremony. DOCX documents also support dynamic content via template data. The unique identifier of the document. Document IDs start with `doc_`. The unique identifier of the envelope, in UUID format. A user-provided identifier for this document within the envelope. Must be unique within the envelope. Use the key to reference this document in other parts of the API. Only lowercase letters, numbers, and underscores are allowed. Must start with a letter. Maximum 32 characters. If not provided, a key is generated automatically. An optional display name for the document. When set, the title is shown to recipients during the signing ceremony and in deliverables. Defaults to `null` if not provided. Maximum 500 characters. The total number of pages in the document after processing. For DOCX templates, this reflects the page count after template data has been merged. The URL where the document or template file is located. The file must be publicly accessible. You can host files on Amazon S3, Google Cloud Storage, Azure Blob Storage, Cloudflare R2, and other services. You can also use the URL returned by the [Create Upload](/docs/api/resources/uploads/create) endpoint. Learn more about your options in [Document URL and Upload](/docs/api/resources/documents/url). The file format of the document. Determines which features are available. * `pdf` -- Standard PDF file. Supports places via placeholders or fixed positions. * `docx` -- Microsoft Word file. Supports template fields for dynamic content in addition to places. For PDF documents the format is `pdf`. The key of the place to position. Must match one of the `key` values in the document's `places` array. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The page number where the place is positioned. Page numbering starts at 1. The vertical distance from the top edge of the page to the bottom-left corner of the place, measured in points (1 point = 1/72 of an inch). For example, `360` places the field 5 inches from the top edge. The horizontal distance from the left edge of the page to the bottom-left corner of the place, measured in points (1 point = 1/72 of an inch). For example, `72` places the field 1 inch from the left edge. Areas within a document where a recipient provides input (such as a signature or text) or where a value is displayed automatically (such as a completion date). Each place has a `type` that determines its behavior. A place must be positioned using either a `[[place_key]]` placeholder in the document text or an entry in the `fixed_positions` array. Learn more about [places](/docs/api/resources/places/object). A location where the recipient, identified by `recipient_key`, draws or types their signature. A single recipient can have multiple signature places across different pages of a document. Specifies the type of place. For a signature place, the value must be `signature`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the signature place in points. The width is calculated automatically using a 5:2 ratio based on this height. Must be between 20 and 60. Defaults to 60. A location where the recipient, identified by `recipient_key`, enters their initials. A single recipient can have multiple initials places across different pages of a document. Specifies the type of place. For an initials place, the value must be `initials`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the initials place in points. The width equals the height. Must be between 20 and 60. Defaults to 60. A read-only text value displayed at a specific location on the document. It is not interactive and does not require a recipient. Use this to pre-fill static information such as company names, reference numbers, or dates before the signing process begins. Specifies the type of place. For a text place, the value must be `text`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The text content to display on the document. This is a static value set when the envelope is created and cannot be changed by the recipient. Maximum length is 1000 characters. The font size in points. Must be between 1 and 144. The default is 12. The font color for this text place. Must be a six-digit hex color code with a leading `#`. Defaults to `#000000` (black). A location where the recipient, identified by `recipient_key`, types free-form text. Supports input validation, placeholder text, and tooltip hints. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a text input place, the value must be `text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. Defines the validation format for the user’s input. Accepted values: * `email` * `zipcode-us` * a custom regular expression, enclosed in `/`, for example: `/^[a-z0-9]{1,10}$/` Learn more in [Format Validation](/docs/api/resources/places/text-input#format-validation). The message displayed when the user’s input does not match the required format. Learn more in [Format Validation -> Adding a Custom Message](/docs/api/resources/places/text-input#adding-a-custom-message). The initial width of the text input field in points. The field may expand beyond this width during typing. Must be between 30 and 540. Defaults to 30. The font size in points. Must be between 6 and 12. Defaults to 12. A series of individual character boxes where the recipient, identified by `recipient_key`, enters text one character per box. Use this for structured data such as verification codes, ZIP codes, or the last four digits of an SSN. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a boxed text input place, the value must be `boxed_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The number of individual character boxes to display. Must be between 1 and 100. Each box accepts a single character from the recipient. Specifies whether the recipient must fill all boxes to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. A placeholder message shown inside the first box during the signing ceremony to guide the recipient. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). A tooltip message displayed over the boxed text input field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The total width of the boxed input field in points. Must be between 30 and 540. The default is 30. The height of each individual box in points. The font size in points. Must be between 6 and 12. The default is 12. A location where the recipient, identified by `recipient_key`, enters text that spans multiple lines. Use this for comments, addresses, and longer descriptions. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a multi-line text input place, the value must be `multiline_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The width of the multi-line text input place in points. Must be between 30 and 540. The default is 30. The number of lines for the multi-line text input field. Must be between 1 and 100. The line height in points. Must be greater than or equal to `font_size`. Must be between 6 and 72. The default is 12. The font size in points. Must be between 6 and 12. The default is 12. A location where the recipient, identified by `recipient_key`, checks or unchecks a box. Use `capture_as` to store the checkbox value in the envelope's captures. Specifies the type of place. For a checkbox place, the value must be `checkbox`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The symbol to display in the checkbox when it is checked. Available options are `check` and `xmark`. The default is `check`. Specifies whether the recipient must check this box to complete the signing ceremony. Possible values are `required` or `optional`. The default is `optional`. The height of the checkbox in points. The width equals the height. Must be between 8 and 40. Defaults to 20. A location where the recipient, identified by `recipient_key`, selects from a list of options. Options can be a custom list of label-value pairs or a predefined set such as country names or US state codes. Use `capture_as` to store the selected value in the envelope's captures. Specifies the type of place. For a dropdown place, the value must be `dropdown`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The list of options available in the dropdown. Either an array of custom `label`/`value` pairs, or a string specifying a predefined option set such as `us_states_names` or `world_countries_names`. The pre-selected option when the dropdown is displayed. The display behavior of the dropdown. Possible values: `auto`, `select`, or `combobox`. Whether the recipient must select an option. Possible values: `required` or `optional`. A placeholder message shown inside the dropdown field during the signing ceremony. A tooltip message displayed when the user hovers over or focuses on the dropdown field. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The font size in points for the dropdown field. The width of the dropdown field in points. Displays the date and time when the recipient, identified by `recipient_key`, completed their action on the envelope. Use `date_format` to control how the date is formatted. Specifies the type of place. For this kind of place, the value must be `recipient_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. Displays the date and time when the envelope was completed. The envelope completes when all recipients have finished their actions. Use `date_format` to control how the date is formatted. Specifies the type of place. For this kind of place, the value must be `envelope_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. Displays the name of the recipient, identified by `recipient_key`, at a specific location on the document. The value is inserted automatically. This place is read-only and does not require any action from the recipient. Specifies the type of place. For this kind of place, the value must be `recipient_name`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. Displays the email address of the recipient, identified by `recipient_key`, at a specific location on the document. The value is inserted automatically. This place is read-only and does not require any action from the recipient. Specifies the type of place. For this kind of place, the value must be `recipient_email`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The unique identifier of the document. Document IDs start with `doc_`. The unique identifier of the envelope, in UUID format. A user-provided identifier for this document within the envelope. Must be unique within the envelope. Use the key to reference this document in other parts of the API. Only lowercase letters, numbers, and underscores are allowed. Must start with a letter. Maximum 32 characters. If not provided, a key is generated automatically. An optional display name for the document. When set, the title is shown to recipients during the signing ceremony and in deliverables. Defaults to `null` if not provided. Maximum 500 characters. The total number of pages in the document after processing. For DOCX templates, this reflects the page count after template data has been merged. The URL where the document or template file is located. The file must be publicly accessible. You can host files on Amazon S3, Google Cloud Storage, Azure Blob Storage, Cloudflare R2, and other services. You can also use the URL returned by the [Create Upload](/docs/api/resources/uploads/create) endpoint. Learn more about your options in [Document URL and Upload](/docs/api/resources/documents/url). The file format of the document. Determines which features are available. * `pdf` -- Standard PDF file. Supports places via placeholders or fixed positions. * `docx` -- Microsoft Word file. Supports template fields for dynamic content in addition to places. For DOCX documents the format is `docx`. Template data used to fill dynamic fields in a DOCX template. Each key corresponds to a `{{key}}` placeholder in the template file. Keys must be alphanumeric and at most 32 characters. Values can be strings, booleans, or nested objects. Nested keys map to dot-notation placeholders (for example, a key `person` with nested key `name` fills `{{person.name}}`). Defaults to `{}`. The key of the place to position. Must match one of the `key` values in the document's `places` array. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The page number where the place is positioned. Page numbering starts at 1. The vertical distance from the top edge of the page to the bottom-left corner of the place, measured in points (1 point = 1/72 of an inch). For example, `360` places the field 5 inches from the top edge. The horizontal distance from the left edge of the page to the bottom-left corner of the place, measured in points (1 point = 1/72 of an inch). For example, `72` places the field 1 inch from the left edge. Areas within a document where a recipient provides input (such as a signature or text) or where a value is displayed automatically (such as a completion date). Each place has a `type` that determines its behavior. A place must be positioned using either a `[[place_key]]` placeholder in the document text or an entry in the `fixed_positions` array. Learn more about [places](/docs/api/resources/places/object). A location where the recipient, identified by `recipient_key`, draws or types their signature. A single recipient can have multiple signature places across different pages of a document. Specifies the type of place. For a signature place, the value must be `signature`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the signature place in points. The width is calculated automatically using a 5:2 ratio based on this height. Must be between 20 and 60. Defaults to 60. A location where the recipient, identified by `recipient_key`, enters their initials. A single recipient can have multiple initials places across different pages of a document. Specifies the type of place. For an initials place, the value must be `initials`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the initials place in points. The width equals the height. Must be between 20 and 60. Defaults to 60. A read-only text value displayed at a specific location on the document. It is not interactive and does not require a recipient. Use this to pre-fill static information such as company names, reference numbers, or dates before the signing process begins. Specifies the type of place. For a text place, the value must be `text`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The text content to display on the document. This is a static value set when the envelope is created and cannot be changed by the recipient. Maximum length is 1000 characters. The font size in points. Must be between 1 and 144. The default is 12. The font color for this text place. Must be a six-digit hex color code with a leading `#`. Defaults to `#000000` (black). A location where the recipient, identified by `recipient_key`, types free-form text. Supports input validation, placeholder text, and tooltip hints. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a text input place, the value must be `text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. Defines the validation format for the user’s input. Accepted values: * `email` * `zipcode-us` * a custom regular expression, enclosed in `/`, for example: `/^[a-z0-9]{1,10}$/` Learn more in [Format Validation](/docs/api/resources/places/text-input#format-validation). The message displayed when the user’s input does not match the required format. Learn more in [Format Validation -> Adding a Custom Message](/docs/api/resources/places/text-input#adding-a-custom-message). The initial width of the text input field in points. The field may expand beyond this width during typing. Must be between 30 and 540. Defaults to 30. The font size in points. Must be between 6 and 12. Defaults to 12. A series of individual character boxes where the recipient, identified by `recipient_key`, enters text one character per box. Use this for structured data such as verification codes, ZIP codes, or the last four digits of an SSN. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a boxed text input place, the value must be `boxed_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The number of individual character boxes to display. Must be between 1 and 100. Each box accepts a single character from the recipient. Specifies whether the recipient must fill all boxes to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. A placeholder message shown inside the first box during the signing ceremony to guide the recipient. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). A tooltip message displayed over the boxed text input field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The total width of the boxed input field in points. Must be between 30 and 540. The default is 30. The height of each individual box in points. The font size in points. Must be between 6 and 12. The default is 12. A location where the recipient, identified by `recipient_key`, enters text that spans multiple lines. Use this for comments, addresses, and longer descriptions. Use `capture_as` to store the entered value in the envelope's captures. Specifies the type of place. For a multi-line text input place, the value must be `multiline_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The width of the multi-line text input place in points. Must be between 30 and 540. The default is 30. The number of lines for the multi-line text input field. Must be between 1 and 100. The line height in points. Must be greater than or equal to `font_size`. Must be between 6 and 72. The default is 12. The font size in points. Must be between 6 and 12. The default is 12. A location where the recipient, identified by `recipient_key`, checks or unchecks a box. Use `capture_as` to store the checkbox value in the envelope's captures. Specifies the type of place. For a checkbox place, the value must be `checkbox`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The symbol to display in the checkbox when it is checked. Available options are `check` and `xmark`. The default is `check`. Specifies whether the recipient must check this box to complete the signing ceremony. Possible values are `required` or `optional`. The default is `optional`. The height of the checkbox in points. The width equals the height. Must be between 8 and 40. Defaults to 20. A location where the recipient, identified by `recipient_key`, selects from a list of options. Options can be a custom list of label-value pairs or a predefined set such as country names or US state codes. Use `capture_as` to store the selected value in the envelope's captures. Specifies the type of place. For a dropdown place, the value must be `dropdown`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The list of options available in the dropdown. Either an array of custom `label`/`value` pairs, or a string specifying a predefined option set such as `us_states_names` or `world_countries_names`. The pre-selected option when the dropdown is displayed. The display behavior of the dropdown. Possible values: `auto`, `select`, or `combobox`. Whether the recipient must select an option. Possible values: `required` or `optional`. A placeholder message shown inside the dropdown field during the signing ceremony. A tooltip message displayed when the user hovers over or focuses on the dropdown field. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The font size in points for the dropdown field. The width of the dropdown field in points. Displays the date and time when the recipient, identified by `recipient_key`, completed their action on the envelope. Use `date_format` to control how the date is formatted. Specifies the type of place. For this kind of place, the value must be `recipient_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. Displays the date and time when the envelope was completed. The envelope completes when all recipients have finished their actions. Use `date_format` to control how the date is formatted. Specifies the type of place. For this kind of place, the value must be `envelope_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. Displays the name of the recipient, identified by `recipient_key`, at a specific location on the document. The value is inserted automatically. This place is read-only and does not require any action from the recipient. Specifies the type of place. For this kind of place, the value must be `recipient_name`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. Displays the email address of the recipient, identified by `recipient_key`, at a specific location on the document. The value is inserted automatically. This place is read-only and does not require any action from the recipient. Specifies the type of place. For this kind of place, the value must be `recipient_email`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The recipients who participate in the envelope's signing process. An envelope can have between 1 and 10 recipients. Three types are supported: * `signer` -- Signs the documents. * `preparer` -- Fills in fields before signers receive the documents. * `approver` -- Reviews and approves the documents without signing. The unique identifier of the recipient. Recipient IDs use the `re_` prefix. The unique identifier of the envelope, in UUID format. The type of the recipient. Determines what actions the recipient can perform during the ceremony. | Type | Description | | ---------- | -------------------------------------------------------------- | | `signer` | Signs documents. Every envelope must have at least one signer. | | `approver` | Reviews and approves documents without signing. | | `preparer` | Fills in document fields on behalf of another party. | For signers, the type is `signer`. A unique identifier you assign to each recipient in the envelope. Use it to match recipients with the places they should interact with (such as signature fields) and to identify them in events and webhook notifications. The key must start with a lowercase letter. It can contain lowercase letters, numbers, and underscores. Maximum 32 characters. It must be unique within the envelope. The full name of the recipient. Appears in invitation emails and is pre-filled for typed signatures. The email address of the recipient. Used to send invitation emails when `delivery_type` is `email`. The current status of the recipient in the signing workflow. | Status | Description | | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | | `pending` | The envelope has not been sent to the recipient yet. This is the initial status. | | `awaiting` | The recipient is waiting for earlier recipients in the routing order to complete. | | `sent` | The invitation has been sent to the recipient. | | `completed` | The recipient has completed their required actions (for example, signed or approved). | | `rejected` | The recipient declined to complete the envelope. | | `soft_bounced` | The invitation email was temporarily undeliverable (for example, a full mailbox). You can resend the request. | | `hard_bounced` | The invitation email was permanently undeliverable (for example, an invalid address). Use the Replace endpoint to assign a new recipient. | | `failed` | An error occurred and the invitation could not be sent. | | `replaced` | This recipient was replaced with a new one via the Replace endpoint. | The current [ceremony](/docs/api/resources/ceremonies/object) for the recipient.
With **email link authentication**, the recipient receives an email with a direct link to the ceremony. Clicking the link authenticates the recipient and opens the signing session.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email link authentication, this value is `email_link`. The custom subject line used for this recipient's invitation email. `null` if the envelope title is used. The custom message body used for this recipient's invitation email. `null` if the envelope message is used.
With **email code authentication**, the recipient receives an email from SignatureAPI containing a 9-digit code. The recipient must enter this code to authenticate and access the ceremony.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email code authentication, this value is `email_code`.
With **custom authentication**, your application authenticates the recipient. SignatureAPI provides a ceremony URL that you share or embed in your application to give the recipient access.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For custom authentication, this value is `custom`. The name of your company or application that authenticated the recipient. This value appears in the envelope audit log as the authentication provider. Key-value pairs with metadata about the authentication event, such as timestamps, session IDs, and user identifiers. These values appear in the envelope audit log. The values in `data` must be sufficient to verify how the recipient was authenticated. You must retain all records needed to prove the recipient's authentication, such as session information. In cases such as legal proceedings, you may need to provide these records to confirm identity. Review our [Terms & Conditions](https://signatureapi.com/terms) for details.
An HTTPS URL to redirect the recipient to after the ceremony finishes. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The delay in seconds before the ceremony redirects to `redirect_url` (standalone ceremonies) or emits completion events (embedded ceremonies). Defaults to `3`. Allowed range: `0` to `20`. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The format of the ceremony URL. Available options: * `standard` (default): Full-length URL. Works for most use cases. * `short`: Shortened URL. Use this when sharing through space-constrained channels such as SMS or push notifications. Origins allowed to embed this ceremony in an iframe. These values set the `frame-ancestors` directive in the ceremony's Content Security Policy (CSP) header. Sources typically take the form of a scheme and host (for example, `https://app.example.com`). Wildcards are supported (for example, `https://*.example.com`). For all available options, see the [frame-ancestors documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors#sources). Defaults to an empty list (`[]`), which means embedding is not allowed. To allow embedding from all origins (not recommended for production), use `["*"]`. Only the origin (scheme and host) is used. Paths are ignored. The URL where the recipient can access the ceremony. You can share this link with the recipient directly or embed it in your application. This property is `null` when: * The ceremony uses `email_link` authentication. SignatureAPI delivers the URL by email in that case. * The ceremony is not active (for example, it is completed, revoked, or declined). The URL expires 30 days after creation, or when a new ceremony is created for the same recipient.
Controls whether the completed deliverable is automatically emailed to this recipient. | Value | Description | | ------- | ----------------------------------------------------------------------------------------------------------- | | `email` | The completed deliverable is delivered to this recipient by email. This is the default for signers. | | `none` | The completed deliverable is not emailed. Your application is responsible for distributing the deliverable. | The signature methods available to the signer. The first item in the array is shown as the default. | Option | Description | | ------- | ----------------------------------------------------------------------------------- | | `typed` | The signer types their name. It is pre-filled from the recipient's `name` property. | | `drawn` | The signer draws their signature using a mouse, stylus, or touchscreen. | If not specified, both `typed` and `drawn` are available, with `typed` shown first. The time at which the recipient completed their required actions on the envelope (for example, signed or approved), in ISO 8601 format. Returns `null` if the recipient has not yet completed. The time at which the recipient's status last changed, in ISO 8601 format. Updates whenever the recipient transitions to a new status.
How the ceremony is created for the recipient. Available options are `automatic` and `manual`. The default is `automatic`. This property is deprecated. Use the `ceremony` object on the recipient when creating an envelope to control ceremony creation. This property will continue to be supported for backwards compatibility.
The unique identifier of the recipient. Recipient IDs use the `re_` prefix. The unique identifier of the envelope, in UUID format. The type of the recipient. Determines what actions the recipient can perform during the ceremony. | Type | Description | | ---------- | -------------------------------------------------------------- | | `signer` | Signs documents. Every envelope must have at least one signer. | | `approver` | Reviews and approves documents without signing. | | `preparer` | Fills in document fields on behalf of another party. | For preparers, the type is `preparer`. A unique identifier you assign to each recipient in the envelope. Use it to match recipients with the places they should interact with (such as signature fields) and to identify them in events and webhook notifications. The key must start with a lowercase letter. It can contain lowercase letters, numbers, and underscores. Maximum 32 characters. It must be unique within the envelope. The full name of the recipient. Appears in invitation emails and is pre-filled for typed signatures. The email address of the recipient. Used to send invitation emails when `delivery_type` is `email`. The current status of the recipient in the signing workflow. | Status | Description | | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | | `pending` | The envelope has not been sent to the recipient yet. This is the initial status. | | `awaiting` | The recipient is waiting for earlier recipients in the routing order to complete. | | `sent` | The invitation has been sent to the recipient. | | `completed` | The recipient has completed their required actions (for example, signed or approved). | | `rejected` | The recipient declined to complete the envelope. | | `soft_bounced` | The invitation email was temporarily undeliverable (for example, a full mailbox). You can resend the request. | | `hard_bounced` | The invitation email was permanently undeliverable (for example, an invalid address). Use the Replace endpoint to assign a new recipient. | | `failed` | An error occurred and the invitation could not be sent. | | `replaced` | This recipient was replaced with a new one via the Replace endpoint. | The current [ceremony](/docs/api/resources/ceremonies/object) for the recipient.
With **email link authentication**, the recipient receives an email with a direct link to the ceremony. Clicking the link authenticates the recipient and opens the signing session.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email link authentication, this value is `email_link`. The custom subject line used for this recipient's invitation email. `null` if the envelope title is used. The custom message body used for this recipient's invitation email. `null` if the envelope message is used.
With **email code authentication**, the recipient receives an email from SignatureAPI containing a 9-digit code. The recipient must enter this code to authenticate and access the ceremony.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email code authentication, this value is `email_code`.
With **custom authentication**, your application authenticates the recipient. SignatureAPI provides a ceremony URL that you share or embed in your application to give the recipient access.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For custom authentication, this value is `custom`. The name of your company or application that authenticated the recipient. This value appears in the envelope audit log as the authentication provider. Key-value pairs with metadata about the authentication event, such as timestamps, session IDs, and user identifiers. These values appear in the envelope audit log. The values in `data` must be sufficient to verify how the recipient was authenticated. You must retain all records needed to prove the recipient's authentication, such as session information. In cases such as legal proceedings, you may need to provide these records to confirm identity. Review our [Terms & Conditions](https://signatureapi.com/terms) for details.
An HTTPS URL to redirect the recipient to after the ceremony finishes. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The delay in seconds before the ceremony redirects to `redirect_url` (standalone ceremonies) or emits completion events (embedded ceremonies). Defaults to `3`. Allowed range: `0` to `20`. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The format of the ceremony URL. Available options: * `standard` (default): Full-length URL. Works for most use cases. * `short`: Shortened URL. Use this when sharing through space-constrained channels such as SMS or push notifications. Origins allowed to embed this ceremony in an iframe. These values set the `frame-ancestors` directive in the ceremony's Content Security Policy (CSP) header. Sources typically take the form of a scheme and host (for example, `https://app.example.com`). Wildcards are supported (for example, `https://*.example.com`). For all available options, see the [frame-ancestors documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors#sources). Defaults to an empty list (`[]`), which means embedding is not allowed. To allow embedding from all origins (not recommended for production), use `["*"]`. Only the origin (scheme and host) is used. Paths are ignored. The URL where the recipient can access the ceremony. You can share this link with the recipient directly or embed it in your application. This property is `null` when: * The ceremony uses `email_link` authentication. SignatureAPI delivers the URL by email in that case. * The ceremony is not active (for example, it is completed, revoked, or declined). The URL expires 30 days after creation, or when a new ceremony is created for the same recipient.
Controls how the recipient receives the invitation to access the envelope. Also determines whether the completed deliverable is emailed to this recipient. | Value | Description | | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `email` | SignatureAPI sends an invitation email with the ceremony link. The completed deliverable is also delivered by email. | | `none` | No emails are sent. Your application is responsible for distributing the ceremony URL and the completed deliverable. This is the default for approvers and preparers. | The time at which the recipient completed their required actions on the envelope (for example, signed or approved), in ISO 8601 format. Returns `null` if the recipient has not yet completed. The time at which the recipient's status last changed, in ISO 8601 format. Updates whenever the recipient transitions to a new status.
How the ceremony is created for the recipient. Available options are `automatic` and `manual`. The default is `automatic`. This property is deprecated. Use the `ceremony` object on the recipient when creating an envelope to control ceremony creation. This property will continue to be supported for backwards compatibility.
The unique identifier of the recipient. Recipient IDs use the `re_` prefix. The unique identifier of the envelope, in UUID format. The type of the recipient. Determines what actions the recipient can perform during the ceremony. | Type | Description | | ---------- | -------------------------------------------------------------- | | `signer` | Signs documents. Every envelope must have at least one signer. | | `approver` | Reviews and approves documents without signing. | | `preparer` | Fills in document fields on behalf of another party. | For approvers, the type is `approver`. A unique identifier you assign to each recipient in the envelope. Use it to match recipients with the places they should interact with (such as signature fields) and to identify them in events and webhook notifications. The key must start with a lowercase letter. It can contain lowercase letters, numbers, and underscores. Maximum 32 characters. It must be unique within the envelope. The full name of the recipient. Appears in invitation emails and is pre-filled for typed signatures. The email address of the recipient. Used to send invitation emails when `delivery_type` is `email`. The current status of the recipient in the signing workflow. | Status | Description | | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | | `pending` | The envelope has not been sent to the recipient yet. This is the initial status. | | `awaiting` | The recipient is waiting for earlier recipients in the routing order to complete. | | `sent` | The invitation has been sent to the recipient. | | `completed` | The recipient has completed their required actions (for example, signed or approved). | | `rejected` | The recipient declined to complete the envelope. | | `soft_bounced` | The invitation email was temporarily undeliverable (for example, a full mailbox). You can resend the request. | | `hard_bounced` | The invitation email was permanently undeliverable (for example, an invalid address). Use the Replace endpoint to assign a new recipient. | | `failed` | An error occurred and the invitation could not be sent. | | `replaced` | This recipient was replaced with a new one via the Replace endpoint. | The current [ceremony](/docs/api/resources/ceremonies/object) for the recipient.
With **email link authentication**, the recipient receives an email with a direct link to the ceremony. Clicking the link authenticates the recipient and opens the signing session.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email link authentication, this value is `email_link`. The custom subject line used for this recipient's invitation email. `null` if the envelope title is used. The custom message body used for this recipient's invitation email. `null` if the envelope message is used.
With **email code authentication**, the recipient receives an email from SignatureAPI containing a 9-digit code. The recipient must enter this code to authenticate and access the ceremony.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email code authentication, this value is `email_code`.
With **custom authentication**, your application authenticates the recipient. SignatureAPI provides a ceremony URL that you share or embed in your application to give the recipient access.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For custom authentication, this value is `custom`. The name of your company or application that authenticated the recipient. This value appears in the envelope audit log as the authentication provider. Key-value pairs with metadata about the authentication event, such as timestamps, session IDs, and user identifiers. These values appear in the envelope audit log. The values in `data` must be sufficient to verify how the recipient was authenticated. You must retain all records needed to prove the recipient's authentication, such as session information. In cases such as legal proceedings, you may need to provide these records to confirm identity. Review our [Terms & Conditions](https://signatureapi.com/terms) for details.
An HTTPS URL to redirect the recipient to after the ceremony finishes. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The delay in seconds before the ceremony redirects to `redirect_url` (standalone ceremonies) or emits completion events (embedded ceremonies). Defaults to `3`. Allowed range: `0` to `20`. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The format of the ceremony URL. Available options: * `standard` (default): Full-length URL. Works for most use cases. * `short`: Shortened URL. Use this when sharing through space-constrained channels such as SMS or push notifications. Origins allowed to embed this ceremony in an iframe. These values set the `frame-ancestors` directive in the ceremony's Content Security Policy (CSP) header. Sources typically take the form of a scheme and host (for example, `https://app.example.com`). Wildcards are supported (for example, `https://*.example.com`). For all available options, see the [frame-ancestors documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors#sources). Defaults to an empty list (`[]`), which means embedding is not allowed. To allow embedding from all origins (not recommended for production), use `["*"]`. Only the origin (scheme and host) is used. Paths are ignored. The URL where the recipient can access the ceremony. You can share this link with the recipient directly or embed it in your application. This property is `null` when: * The ceremony uses `email_link` authentication. SignatureAPI delivers the URL by email in that case. * The ceremony is not active (for example, it is completed, revoked, or declined). The URL expires 30 days after creation, or when a new ceremony is created for the same recipient.
Controls how the recipient receives the invitation to access the envelope. Also determines whether the completed deliverable is emailed to this recipient. | Value | Description | | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `email` | SignatureAPI sends an invitation email with the ceremony link. The completed deliverable is also delivered by email. | | `none` | No emails are sent. Your application is responsible for distributing the ceremony URL and the completed deliverable. This is the default for approvers and preparers. | The time at which the recipient completed their required actions on the envelope (for example, signed or approved), in ISO 8601 format. Returns `null` if the recipient has not yet completed. The time at which the recipient's status last changed, in ISO 8601 format. Updates whenever the recipient transitions to a new status.
How the ceremony is created for the recipient. Available options are `automatic` and `manual`. The default is `automatic`. This property is deprecated. Use the `ceremony` object on the recipient when creating an envelope to control ceremony creation. This property will continue to be supported for backwards compatibility.
The regulatory attestation applied to the envelope. Use this to meet country-specific e-signature requirements. * `none` -- No attestation. This is the default and covers most countries, including the US and EU member states. * `mx_nom151` -- Mexico NOM-151 compliance. Attaches a preservation certificate to the deliverable. For more information, see [Attestation](/docs/api/resources/envelopes/attestation). The deliverable that was automatically generated when the envelope was completed. The standard deliverable includes an audit log. To get signed documents without an audit log, use the [simple deliverable](/docs/api/resources/deliverables/simple) instead. The unique identifier for this deliverable. A user-provided name for this deliverable. Use this to identify deliverables when an envelope has more than one. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Between 1 and 32 characters. The unique identifier of the envelope, in UUID format. The type of the deliverable. * `standard`: Includes the signed documents and an audit log with a certificate of completion. This is the default. * `simple`: Includes the signed documents only, without an audit log. For standard deliverables, the type is `standard`. The current status of the deliverable. * `pending`: The envelope is not yet completed. The deliverable is waiting to be generated. * `processing`: The envelope has completed and the deliverable is being generated. This usually takes a few seconds. * `generated`: The deliverable is ready. The `url` property contains a download link. * `failed`: The deliverable failed to generate. This is rare. SignatureAPI support is notified automatically. The URL for downloading the deliverable. `null` until the deliverable reaches `generated` status. By default, this is a pre-signed URL. It requires no additional authentication and expires after 1 hour. If the link has expired, retrieve the deliverable again to get a fresh URL. If your account uses authenticated URLs (for HIPAA compliance, for example), access this URL with your API key as you would any other API request. Authenticated URLs do not expire. The language for system-generated text in the audit log, including labels and the certificate of completion. Does not affect the content of the signed documents. Supported values: `en` (English), `es` (Spanish), `fr` (French), `it` (Italian), `pt` (Portuguese), `de` (German), `zh` (Chinese Simplified), `hu` (Hungarian). Defaults to the envelope language. The timezone used for timestamps in the audit log. Must be a valid IANA Time Zone Database identifier (e.g., `America/New_York`, `Europe/London`). Does not affect timestamps inside the signed documents. Defaults to the envelope timezone. The format for timestamps in the audit log. Uses MomentJS format tokens (e.g., `MM/DD/YYYY HH:mm:ss`). Does not affect timestamps inside the signed documents. Defaults to the envelope timestamp format. The keys of the documents to include in the deliverable. By default, all documents in the envelope are included. Use this to create a deliverable with only a subset of documents. For example, generate separate deliverables for different recipients. Accepts between 1 and 10 document keys. The password used to encrypt the deliverable. Recipients must enter this password to access the downloaded file. Password requirements: * Between 4 and 32 characters * Letters and numbers only (no special characters or spaces) When returned in API responses, the password value is masked for security (displayed as `********`). Password protection is available upon request. [Contact support](https://signatureapi.com/support) to enable this feature. The time the deliverable was created, in ISO 8601 format. Set when the envelope is created, or when a deliverable is created via the API. The time the deliverable was successfully generated, in ISO 8601 format. `null` until the deliverable reaches `generated` status. The simple deliverable does not include an audit log. To get signed documents with an audit log, use the [standard deliverable](/docs/api/resources/deliverables/standard) instead. The unique identifier for this deliverable. A user-provided name for this deliverable. Use this to identify deliverables when an envelope has more than one. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Between 1 and 32 characters. The unique identifier of the envelope, in UUID format. The type of the deliverable. * `standard`: Includes the signed documents and an audit log with a certificate of completion. This is the default. * `simple`: Includes the signed documents only, without an audit log. For simple deliverables, the type is `simple`. The current status of the deliverable. * `pending`: The envelope is not yet completed. The deliverable is waiting to be generated. * `processing`: The envelope has completed and the deliverable is being generated. This usually takes a few seconds. * `generated`: The deliverable is ready. The `url` property contains a download link. * `failed`: The deliverable failed to generate. This is rare. SignatureAPI support is notified automatically. The URL for downloading the deliverable. `null` until the deliverable reaches `generated` status. By default, this is a pre-signed URL. It requires no additional authentication and expires after 1 hour. If the link has expired, retrieve the deliverable again to get a fresh URL. If your account uses authenticated URLs (for HIPAA compliance, for example), access this URL with your API key as you would any other API request. Authenticated URLs do not expire. The keys of the documents to include in the deliverable. By default, all documents in the envelope are included. Use this to create a deliverable with only a subset of documents. For example, generate separate deliverables for different recipients. Accepts between 1 and 10 document keys. The password used to encrypt the deliverable. Recipients must enter this password to access the downloaded file. Password requirements: * Between 4 and 32 characters * Letters and numbers only (no special characters or spaces) When returned in API responses, the password value is masked for security (displayed as `********`). Password protection is available upon request. [Contact support](https://signatureapi.com/support) to enable this feature. The time the deliverable was created, in ISO 8601 format. Set when the envelope is created, or when a deliverable is created via the API. The time the deliverable was successfully generated, in ISO 8601 format. `null` until the deliverable reaches `generated` status. Data captured from recipients during the signing ceremony. Each key corresponds to a `capture_as` identifier defined on a text input, checkbox, or dropdown place. Values are strings for text inputs, booleans for checkboxes, or `null` if not yet filled. Learn more about [captures](/docs/api/resources/envelopes/captures). The URL to a PDF snapshot of the envelope, showing documents and signatures collected so far. Returns `null` unless the envelope meets all of the following criteria: * It uses sequential routing. * It is currently in progress (not `completed`). * It was created within 1 year. By default, this is a short-lived, pre-signed URL that requires no further authentication to download. The URL expires after 1 hour. If the link has expired, retrieve the envelope again to generate a new one. If you requested authenticated URLs (for example, to achieve HIPAA compliance), the URL must be accessed using the API key. Authenticated URLs do not expire. The time at which the envelope was created, in ISO 8601 format. The time at which all recipients completed the envelope, in ISO 8601 format. Returns `null` until the envelope reaches `completed` status. ```json Response theme={null} { "id": "55072f0e-b919-4d69-89cd-e7e56af00530", "title": "Exploration Agreement", "label": "Exploration Agreement for Order Ref. 25005", "message": "Please review the agreement and provide your signature.", "status": "completed", "mode": "live", "routing": "sequential", "language": "en", "timezone": "America/New_York", "timestamp_format": "MM/DD/YYYY HH:mm:ss", "attestation": "none", "branding": { "logo": null, "accent_color": "#2463eb", "email": { "from": "noreply@signatureapi.com", "footer": null, "logo_position": "left" } }, "sender": { "name": "Jennifer Lee", "email": "jennifer@example.com", "organization": "Acme Enterprises" }, "topics": [ "sales", "project_blue" ], "metadata": { "customer_ref": "x9550501", "account_annual_revenue": "$4,500,000" }, "documents": [ { "id": "doc_3jBYlxa9gv0fGLzFAnfwxe", "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "title": "Exploration Agreement", "page_count": 2, "url": "https://pub-e5051420e98a4fdfb3fd42a62fbf06fa.r2.dev/dummy.docx", "format": "docx", "data": { "date": "December 31st, 2025", "showAlert": true, "serviceProvider": { "name": "Jane Smith", "organization": "ACME Global, Inc." }, "client": { "name": "Michael J. Miller", "organization": "Miller Industries" } }, "places": [ { "key": "provider_signs_here", "type": "signature", "recipient_key": "service_provider" }, { "key": "client_signs_here", "type": "signature", "recipient_key": "client" } ] } ], "recipients": [ { "id": "re_26w2VVV5JVm4j459TY5BNM", "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "type": "signer", "key": "service_provider", "name": "Jane Smith", "email": "jane@example.com", "status": "completed", "ceremony": { "authentication": [ { "type": "email_link", "subject_override": null, "message_override": null } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": null }, "delivery_type": "email", "ceremony_creation": "automatic", "signature_options": ["typed", "drawn"], "completed_at": "2025-12-31T14:00:00.000Z", "status_updated_at": "2025-12-31T14:00:00.000Z" }, { "id": "re_38UVwrWdCqX5kqeKFJUTtf", "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "type": "signer", "key": "client", "name": "Michael J. Miller", "email": "michael@example.com", "status": "completed", "ceremony": { "authentication": [ { "type": "email_link", "subject_override": null, "message_override": null } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": null }, "delivery_type": "email", "ceremony_creation": "automatic", "signature_options": ["typed", "drawn"], "completed_at": "2025-12-31T15:00:00.000Z", "status_updated_at": "2025-12-31T15:00:00.000Z" } ], "deliverable": { "id": "del_1T7If8GgrTOf7zBVPaJf2e", "name": null, "envelope_id": "55072f0e-b919-4d69-89cd-e7e56af00530", "type": "standard", "status": "generated", "url": "https://s3.us-east-2.amazonaws.com/signatureapi-vault-dev/envelopes/55072f0e...", "language": "en", "timezone": "America/New_York", "timestamp_format": "MM/DD/YYYY HH:mm:ss", "included_documents": null, "password": null, "created_at": "2025-12-31T12:00:00.000Z", "generated_at": "2025-12-31T15:00:05.000Z" }, "captures": {}, "snapshot_url": null, "created_at": "2025-12-31T12:00:00.000Z", "completed_at": "2025-12-31T15:00:00.000Z" } ``` # Recipient routing Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/routing Control signing order with sequential or parallel recipient routing options The `routing` property controls the order in which recipients receive and act on the envelope. Two options are available: `sequential` and `parallel`. The default is `sequential`. ## Sequential routing With sequential routing, the envelope is delivered to one recipient at a time, in the order listed in the `recipients` array. Each recipient must complete their part before the next one is notified. * Recipients act in the order defined in the `recipients` array. * Each recipient must complete before the next one is notified. * Recipients acting later can see signatures and data entered by those who acted before them. * Recipients waiting for a previous recipient will have a status of `awaiting`. * Use this when the order of signatures matters. ## Parallel routing With parallel routing, all recipients receive the envelope at the same time and can act in any order. * All recipients are notified simultaneously. * Recipients can act in any order. * Use this when signing order does not matter. ## Setting routing on an envelope Set the `routing` property when creating an envelope. If omitted, sequential routing is used. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "routing": "parallel", "documents": [ //... ], "recipients": [ //... ] } ``` # Timestamp format Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/timestamp-format Customize the date and time format displayed in deliverables for your recipients The `timestamp_format` property controls how dates and times appear in the deliverable's audit log. It uses MomentJS format tokens. If not specified, the account's default timestamp format is used. Set your account default in the [dashboard settings](https://dashboard.signatureapi.com/settings/general). ## Setting the timestamp format for an envelope ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "timestamp_format": "MM/DD/YYYY HH:mm:ss", "documents": [ //... ], "recipients": [ //... ] } ``` ## Format tokens Use these tokens to build a timestamp format string: | Token | Description | | ------ | -------------------- | | `YYYY` | Year (four digits) | | `MM` | Month (two digits) | | `DD` | Day (two digits) | | `HH` | Hour (24-hour clock) | | `hh` | Hour (12-hour clock) | | `mm` | Minutes | | `ss` | Seconds | Supported date separators: `/`, `-`, `.`, or a space. Supported time separators: `:` or `.`. ## Common formats | Format | Example output | Common usage | | --------------------- | ---------------------- | ----------------------- | | `MM/DD/YYYY HH:mm:ss` | 12/31/2025 23:59:59 | United States | | `DD/MM/YYYY HH:mm:ss` | 31/12/2025 23:59:59 | Europe, Australia | | `YYYY-MM-DD HH:mm:ss` | 2025-12-31 23:59:59 | ISO 8601 | | `MM/DD/YYYY hh:mm:ss` | 12/31/2025 11:59:59 PM | United States (12-hour) | | `DD.MM.YYYY HH:mm.ss` | 31.12.2025 23:59.59 | Germany, Eastern Europe | # Time zone Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/timezone Configure time zones for deliverables at the account or envelope level The `timezone` property sets the time zone used for timestamps in the deliverable's audit log. It must be a valid [IANA Time Zone Database](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) identifier (for example, `America/New_York` or `Europe/London`). If not specified, the account's default time zone is used. Set your account default in the Settings section of the dashboard. ## Setting the time zone for an envelope ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "timezone": "Europe/London", "documents": [ //... ], "recipients": [ //... ] } ``` ## Common identifiers | Identifier | Region | | --------------------- | ----------------- | | `America/New_York` | US East Coast | | `America/Los_Angeles` | US West Coast | | `America/Chicago` | US Central | | `Europe/London` | United Kingdom | | `Europe/Paris` | Central Europe | | `Asia/Singapore` | Singapore | | `Australia/Sydney` | Eastern Australia | Use named identifiers (like `America/New_York`) rather than fixed offsets (like `Etc/GMT+5`). Named identifiers handle daylight saving changes automatically. # Envelope topics Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/topics Organize envelopes with tags and filter webhook notifications by topic Topics are tags you assign to envelopes. They serve two purposes: filtering webhook notifications and querying envelopes by category. You can assign up to 10 topics per envelope. Each topic must start with a lowercase letter and contain only lowercase letters, numbers, and underscores (maximum 32 characters). ## Assigning topics Set the `topics` property when creating an envelope: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Sales Contract", "topics": ["sales", "q1_2026"], "documents": [ //... ], "recipients": [ //... ] } ``` ## Filtering webhooks by topic Configure a webhook endpoint in the dashboard to receive events only for envelopes with specific topics. This lets you route different envelope types to different endpoints or trigger different workflows without building complex routing logic. For example, a company with separate finance and sales workflows can: 1. Tag finance envelopes with `finance` and sales envelopes with `sales`. 2. Configure one webhook endpoint to receive only `finance` events and another for `sales` events. 3. Each endpoint receives only the notifications relevant to its workflow. A webhook with no topic filter receives events for all envelopes. ## Filtering envelopes by topic Use the `topic` query parameter on the [List Envelopes](/docs/api/resources/envelopes/list) endpoint to retrieve envelopes for a specific topic: ```json theme={null} // GET https://api.signatureapi.com/v1/envelopes?topic=sales // X-API-Key: key_test_... ``` ## Topics vs. metadata Use topics to categorize and filter envelopes within SignatureAPI. Use [metadata](/docs/api/resources/envelopes/metadata) to store information that connects envelopes to records in your own systems. # Update an envelope Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/envelopes/update PATCH /v1/envelopes/{envelope_id} Update the label of an existing envelope Updates an envelope by setting the values of the properties passed. Any properties not provided are left unchanged. Currently, only the `label` property can be updated. The label is for internal use and is not shown to recipients. It can be updated regardless of the envelope's status. ## Path parameters The unique identifier of the envelope, in UUID format. ## Body parameters A custom label for internal identification. Labels are not shown to recipients. Unlike `title`, which recipients see, the label is for your team's use only. It can be updated at any time via the Update Envelope endpoint. Maximum 500 characters. Defaults to `null`. ## Returns Returns a `200 OK` status code along with the updated [envelope object](/docs/api/resources/envelopes/object) on success, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // PATCH https://api.signatureapi.com/v1/envelopes/{envelope_id} // X-API-Key: key_test_... // Content-Type: application/json { "label": "Exploration Agreement for Order Ref. 29009" } ``` ```json Response theme={null} // HTTP Status Code 200 { "id": "55072f0e-b919-4d69-89cd-e7e56af00530", "title": "Exploration Agreement", "label": "Exploration Agreement for Order Ref. 29009", //... } ``` # List events Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/events/all GET /v1/events Returns all events across your account, sorted with the most recent first. Returns a list of all events across your account. Events are sorted by timestamp, with the most recent appearing first. Results include envelope, recipient, deliverable, and sender events. ### Query parameters Filter by event type. For example, `envelope.completed` or `recipient.hard_bounced`. For the full list of event types, see: * [Envelope Events](/docs/api/resources/events/envelope-events) * [Recipient Events](/docs/api/resources/events/recipient-events) * [Deliverable Events](/docs/api/resources/events/deliverable-events) * [Sender Events](/docs/api/resources/events/sender-events) The maximum number of objects to return. Minimum is `1`, maximum is `20`. Defaults to `20`. ### Returns Returns a `200 OK` status with a [paginated](/docs/api/pagination) list of [event objects](/docs/api/resources/events/object) on success, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // GET https://api.signatureapi.com/v1/events // X-API-Key: key_test_... ``` ```json Response theme={null} // HTTP Status Code 200 { "links": { "next": "https://api.signatureapi.com/v1/events?cursor=seq_0iuY6H...", "previous": "https://api.signatureapi.com/v1/events?cursor=seq_87unYn..." }, "data": [ { "id": "evt_45b62ui33fCihBWpW2kWDa", "type": "envelope.completed", "timestamp": "2025-12-31T23:59:00.000Z", "data": { "object_id": "2dc5d4bb-5f4e-41a8-aea8-077a48587e31", "object_type": "envelope", "envelope_id": "2dc5d4bb-5f4e-41a8-aea8-077a48587e31", "envelope_metadata": {} } }, { "id": "evt_7BFIYuMgWzJ1AHscS0RNxC", "type": "recipient.completed", "timestamp": "2025-12-31T23:58:59.000Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "2dc5d4bb-5f4e-41a8-aea8-077a48587e31", "envelope_metadata": {}, "recipient_type": "signer", "recipient_key": "client", "session_id": "ses_2X6eHBCL84MDGrLQX0mHI72" } }, //... ] } ``` # Deliverable events Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/events/deliverable-events Receive notifications when signed documents are generated and ready for download. Deliverable events notify you when SignatureAPI generates the final signed document (the deliverable), or when generation fails. This page explains each event type, when it fires, and the additional data included in the payload. ## deliverable.generated Fires when a deliverable is successfully generated and ready for download. The `data.url` property contains a pre-signed download link. This URL expires after 1 hour. If it has expired, call the [Retrieve Deliverable](/docs/api/resources/deliverables/get) endpoint to get a fresh link. ```json JSON theme={null} { "id": "evt_1a2b3c4d5e6f7g8h9i0j", "type": "deliverable.generated", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "del_00ZeZjRaXCgT30n1eBx53N", "object_type": "deliverable", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "deliverable_type": "standard", "deliverable_name": null, "included_documents": ["contract", "addendum"], "url": "https://vault.signatureapi.com/envelopes/e387553d-cbb7-4924-abd8-b2d89699e9b5/deliverables/del_00ZeZjRaXCgT30n1eBx53N/sealed.pdf?Signature=..." } } ``` ## deliverable.failed Fires when deliverable generation fails. The deliverable status is set to `failed`. The `data.detail` property contains a human-readable explanation of the failure. Deliverable failures are rare. SignatureAPI support is notified automatically when this event fires. ```json JSON theme={null} { "id": "evt_2b3c4d5e6f7g8h9i0j1k", "type": "deliverable.failed", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "del_00ZeZjRaXCgT30n1eBx53N", "object_type": "deliverable", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "deliverable_type": "standard", "deliverable_name": null, "included_documents": ["contract", "addendum"], "detail": "The audit log could not be generated due to a system error." } } ``` # List envelope events Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/events/envelope GET /v1/envelopes/{envelope_id}/events Returns all events for a specific envelope, sorted with the most recent first. Returns a list of events for a specific envelope. Events are sorted by timestamp, with the most recent appearing first. Results include envelope events, recipient events, and deliverable events associated with that envelope. ### Path parameters The unique identifier of the envelope. ### Query parameters Filter by event type. For example, `envelope.completed` or `recipient.sent`. For the full list of event types available when listing envelope events, see: * [Envelope Events](/docs/api/resources/events/envelope-events) * [Recipient Events](/docs/api/resources/events/recipient-events) * [Deliverable Events](/docs/api/resources/events/deliverable-events) The maximum number of objects to return. Minimum is `1`, maximum is `20`. Defaults to `20`. ### Returns Returns a `200 OK` status with a [paginated](/docs/api/pagination) list of [event objects](/docs/api/resources/events/object) on success, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // GET https://api.signatureapi.com/v1/envelopes/2dc5d4bb-5f4e-41a8-aea8-077a48587e31/events // X-API-Key: key_test_... ``` ```json Response theme={null} // HTTP Status Code 200 { "links": { "next": "https://api.signatureapi.com/v1/envelopes/2dc5d4bb-5f4e-41a8-aea8-077a48587e31/events?cursor=seq_0iuY6H...", "previous": "https://api.signatureapi.com/v1/envelopes/2dc5d4bb-5f4e-41a8-aea8-077a48587e31/events?cursor=seq_87unYn..." }, "data": [ { "id": "evt_45b62ui33fCihBWpW2kWDa", "type": "envelope.completed", "timestamp": "2025-12-31T23:59:00.000Z", "data": { "object_id": "2dc5d4bb-5f4e-41a8-aea8-077a48587e31", "object_type": "envelope", "envelope_id": "2dc5d4bb-5f4e-41a8-aea8-077a48587e31", "envelope_metadata": {} } }, { "id": "evt_7BFIYuMgWzJ1AHscS0RNxC", "type": "recipient.completed", "timestamp": "2025-12-31T23:58:59.000Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "2dc5d4bb-5f4e-41a8-aea8-077a48587e31", "envelope_metadata": {}, "recipient_type": "signer", "recipient_key": "client", "session_id": "ses_2X6eHBCL84MDGrLQX0mHI72" } }, //... ] } ``` # Envelope events Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/events/envelope-events Track envelope lifecycle changes including creation, completion, cancellation, and failure. Envelope events track key changes in the lifecycle of an envelope. This page describes each event type, when it fires, and the additional data included in the payload. ## envelope.created Fires when a new envelope is created. The envelope is in `processing` status and has not yet been sent to recipients. Use this event to record that a signing process has started in your system. ```json JSON theme={null} { "id": "evt_4p2oouvNvjp1I9ckgqycH2", "type": "envelope.created", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "object_type": "envelope", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." } } } ``` ## envelope.started Fires when the envelope finishes processing and transitions from `processing` to `in_progress` status. Recipients are now being notified. For sequential routing, the first recipient receives the signing request. For parallel routing, all recipients receive it at the same time. ```json JSON theme={null} { "id": "evt_5a2b3c4d5e6f7g8h9i0j", "type": "envelope.started", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "object_type": "envelope", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." } } } ``` ## envelope.completed Fires when all recipients have completed the envelope. The envelope status changes from `in_progress` to `completed`. Use this event to trigger downstream workflows such as storing signed documents, updating records, or notifying your team. ```json JSON theme={null} { "id": "evt_6b7c8d9e0f1g2h3i4j5k", "type": "envelope.completed", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "object_type": "envelope", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." } } } ``` ## envelope.failed Fires when an envelope encounters an internal error and transitions to `failed` status. The `data.detail` property contains a human-readable explanation of the failure. Envelope failures are very rare. SignatureAPI engineers receive an automatic alert and begin investigating when this event fires. Contact support for additional information. ```json JSON theme={null} { "id": "evt_7c8d9e0f1g2h3i4j5k6l", "type": "envelope.failed", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "object_type": "envelope", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "detail": "Could not parse input PDF document." } } ``` ## envelope.canceled Fires when the envelope is explicitly canceled by calling the [Cancel Envelope](/docs/api/resources/envelopes/cancel) endpoint. The envelope status changes to `canceled`, which is a terminal state. The `data.reason` property contains the cancellation reason if one was provided, or `null` if none was given. ```json JSON theme={null} { "id": "evt_8d9e0f1g2h3i4j5k6l7m", "type": "envelope.canceled", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "object_type": "envelope", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "reason": "Insurance policy offer expired." } } ``` # Event Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/events/object The event object records changes and actions in your account, delivered via webhooks or retrievable through the API. Events record changes and actions in your SignatureAPI account. Examples include an [envelope completing](/docs/api/resources/events/envelope-events#envelope-completed) and a [recipient email bouncing](/docs/api/resources/events/recipient-events#recipient-hard-bounced). You receive events as webhook notifications. You can also retrieve them through the API, either [for all events in your account](/docs/api/resources/events/all) or for a [specific envelope](/docs/api/resources/events/envelope) or [recipient](/docs/api/resources/events/recipient). ## Typical event flow A standard signing flow produces events in this order: 1. `envelope.created`: Envelope is created and processing begins. 2. `envelope.started`: Processing complete, recipients are being notified. 3. `recipient.released`: Recipient is ready to receive an invitation. 4. `recipient.sent`: Invitation email delivered (only when `delivery_type` is `email`). 5. `recipient.accessed`: Recipient opens the ceremony URL. 6. `recipient.viewed`: Recipient authenticates and views the documents. 7. `recipient.completed`: Recipient finishes signing. 8. `envelope.completed`: All recipients done, envelope is complete. 9. `deliverable.generated`: Signed PDF is ready for download. For sequential routing, steps 3-7 repeat for each recipient in order. For parallel routing, multiple recipients go through steps 3-7 at the same time. Events may arrive out of order. Your application should handle this gracefully. See [Webhooks](/docs/api/webhooks) for delivery details. ## Attributes The unique identifier of the event. Uses the `evt_` prefix. The type of the event. Determines the category and the shape of the `data` payload. Event types are grouped into four categories: envelope, recipient, deliverable, and sender. For the full list of event types, see: * [Envelope Events](/docs/api/resources/events/envelope-events) * [Recipient Events](/docs/api/resources/events/recipient-events) * [Deliverable Events](/docs/api/resources/events/deliverable-events) * [Sender Events](/docs/api/resources/events/sender-events) When the event occurred, in ISO 8601 format. The data associated with the event. The shape of this object depends on the event `type`. These properties are common to all envelope events. Some event types include additional properties. See [Envelope Events](/docs/api/resources/events/envelope-events) for details. The unique identifier of the resource this event refers to. For envelope events, this value is the envelope ID. The type of resource this event refers to. For envelope events, the value is `envelope`. The ID of the envelope this event refers to. For envelope events, this value is the same as `object_id`. The metadata attached to the envelope. These properties are common to all recipient events. Some event types include additional properties. See [Recipient Events](/docs/api/resources/events/recipient-events) for details. The unique identifier of the resource this event refers to. For recipient events, this value is the recipient ID. The type of resource this event refers to. For recipient events, the value is `recipient`. The ID of the envelope the recipient belongs to. The metadata attached to the envelope the recipient belongs to. The type of the recipient. Possible values: `signer`, `approver`, `preparer`. A user-provided key that identifies the recipient within an envelope. These properties are common to all deliverable events. Some event types include additional properties. See [Deliverable Events](/docs/api/resources/events/deliverable-events) for details. The unique identifier of the resource this event refers to. For deliverable events, this value is the deliverable ID. The type of resource this event refers to. For deliverable events, the value is `deliverable`. The ID of the envelope the deliverable belongs to. The metadata attached to the envelope the deliverable belongs to. The type of the deliverable. Possible values: `simple`, `standard`. A user-provided name for the deliverable. The keys of the documents included in the deliverable. These properties are common to all sender events. Some event types include additional properties. See [Sender Events](/docs/api/resources/events/sender-events) for details. The unique identifier of the sender this event refers to. The type of resource this event refers to. For sender events, the value is `sender`. The email address of the sender this event refers to. ```json Response theme={null} { "id": "evt_4p2oouvNvjp1I9ckgqycH2", "type": "recipient.completed", "timestamp": "2025-12-31T15:00:01.999Z", "data": { "object_id": "re_7v7Sion0vqjJioYmwfZ9mf", "object_type": "recipient", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "recipient_type": "signer", "recipient_key": "client", "session_id": "ses_2X6eHBCL84MDGrLQX0mHI72" } } ``` # List recipient events Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/events/recipient GET /v1/recipients/{recipient_id}/events Returns all events for a specific recipient, sorted with the most recent first. Returns a list of events for a specific recipient. Events are sorted by timestamp, with the most recent appearing first. Results include only recipient events, such as delivery, signing, and bounce events. ### Path parameters The unique identifier of the recipient. ### Query parameters Filter by event type. For example, `recipient.completed` or `recipient.sent`. For the full list of event types available when listing recipient events, see [Recipient Events](/docs/api/resources/events/recipient-events). The maximum number of objects to return. Minimum is `1`, maximum is `20`. Defaults to `20`. ### Returns Returns a `200 OK` status with a [paginated](/docs/api/pagination) list of [event objects](/docs/api/resources/events/object) on success, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // GET https://api.signatureapi.com/v1/recipients/re_00ZeZjRaXCgT30n1eBx53N/events // X-API-Key: key_test_... ``` ```json Response theme={null} // HTTP Status Code 200 { "links": { "next": "https://api.signatureapi.com/v1/recipients/re_00ZeZjRaXCgT30n1eBx53N/events?cursor=seq_0iuY6H...", "previous": "https://api.signatureapi.com/v1/recipients/re_00ZeZjRaXCgT30n1eBx53N/events?cursor=seq_87unYn..." }, "data": [ { "id": "evt_45b62ui33fCihBWpW2kWDa", "type": "recipient.completed", "timestamp": "2025-12-31T23:58:00.000Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "2dc5d4bb-5f4e-41a8-aea8-077a48587e31", "envelope_metadata": {}, "recipient_type": "signer", "recipient_key": "client", "session_id": "ses_2X6eHBCL84MDGrLQX0mHI72" } }, { "id": "evt_7BFIYuMgWzJ1AHscS0RNxC", "type": "recipient.sent", "timestamp": "2025-12-31T23:50:00.000Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "2dc5d4bb-5f4e-41a8-aea8-077a48587e31", "envelope_metadata": {}, "recipient_type": "signer", "recipient_key": "client" } }, //... ] } ``` # Recipient events Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/events/recipient-events Monitor recipient actions and status changes including signing, bounces, and replacements. Recipient events track key actions and status changes for recipients within an envelope. This page describes each event type, when it fires, and the additional data included in the payload. ## recipient.released Fires when a recipient becomes ready to receive an invitation. The recipient status changes to `pending`. This event fires after all previous recipients in the routing order have completed, or immediately for the first recipient when the envelope starts. ```json JSON theme={null} { "id": "evt_1a2b3c4d5e6f7g8h9i0j", "type": "recipient.released", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "recipient_type": "signer", "recipient_key": "client" } } ``` ## recipient.sent Fires when SignatureAPI sends the invitation email to a recipient. The recipient status changes to `sent`. This event only fires for recipients with `delivery_type` set to `email`. ```json JSON theme={null} { "id": "evt_2b3c4d5e6f7g8h9i0j1k", "type": "recipient.sent", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "recipient_type": "signer", "recipient_key": "client" } } ``` ## recipient.accessed Fires when a recipient opens the ceremony URL. To reduce duplicate events, this fires at most once every 60 seconds for the same IP address and user agent combination. The recipient has not yet authenticated at this point. The `data` object includes the recipient's `ip` address, `user_agent`, and a `session_id`. Use `session_id` to correlate multiple events from the same ceremony session. Some security platforms access the ceremony URL to prefetch content or scan for threats. These requests can trigger `recipient.accessed` before the intended recipient opens the link. To confirm that the human recipient has accessed the ceremony, use the `recipient.viewed` event instead. ```json JSON theme={null} { "id": "evt_2b3c4d5e6f7g8h9i0j1k", "type": "recipient.accessed", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "recipient_type": "signer", "recipient_key": "client", "ip": "123.122.990.22", "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36", "session_id": "ses_2X6eHBCL84MDGrLQX0mHI72" } } ``` ## recipient.viewed Fires after a recipient authenticates and the documents are displayed in the ceremony. This confirms the recipient passed all authentication steps and can view the documents. The `data` object includes a `session_id`. Use it to correlate multiple events from the same ceremony session. ```json JSON theme={null} { "id": "evt_2b3c4d5e6f7g8h9i0j1k", "type": "recipient.viewed", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "recipient_type": "signer", "recipient_key": "client", "session_id": "ses_2X6eHBCL84MDGrLQX0mHI72" } } ``` ## recipient.completed Fires when a recipient finishes all required actions in the ceremony. The recipient status changes to `completed`. For signers, this means they have signed and finalized. For approvers and preparers, this means they have reviewed and submitted their inputs. The `data` object includes a `session_id`. Use it to correlate multiple events from the same ceremony session. ```json JSON theme={null} { "id": "evt_3c4d5e6f7g8h9i0j1k2l", "type": "recipient.completed", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "recipient_type": "signer", "recipient_key": "client", "session_id": "ses_2X6eHBCL84MDGrLQX0mHI72" } } ``` ## recipient.rejected Fires when a recipient declines the envelope. When a recipient rejects, the entire envelope is voided. The `data.reason` property contains the recipient's explanation if they provided one. It is an empty string if no reason was given. The `data` object also includes a `session_id`. ```json JSON theme={null} { "id": "evt_4d5e6f7g8h9i0j1k2l3m", "type": "recipient.rejected", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "recipient_type": "signer", "recipient_key": "client", "reason": "Not the terms we agreed to on June.", "session_id": "ses_2X6eHBCL84MDGrLQX0mHI72" } } ``` ## recipient.soft\_bounced Fires when the invitation email is temporarily undeliverable. The recipient status changes to `soft_bounced`. Common causes include a full mailbox or a temporary server issue. The `data.detail` property contains the bounce reason from the remote email server. Use the [Resend Request](/docs/api/resources/recipients/resend) endpoint to try delivering the invitation again. ```json JSON theme={null} { "id": "evt_5e6f7g8h9i0j1k2l3m4n", "type": "recipient.soft_bounced", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "recipient_type": "signer", "recipient_key": "client", "detail": "Server 123.122.990.22 responded with: Mailbox Full" } } ``` ## recipient.hard\_bounced Fires when the invitation email is permanently undeliverable. The recipient status changes to `hard_bounced`. Common causes include an invalid or nonexistent email address. The `data.detail` property contains the bounce reason from the remote email server. You can view further details, such as SMTP responses, in the Dashboard. After a hard bounce, you cannot resend to this recipient. Use the [Replace Recipient](/docs/api/resources/recipients/replace) endpoint to assign a new person with a valid email address. ```json JSON theme={null} { "id": "evt_6f7g8h9i0j1k2l3m4n5o", "type": "recipient.hard_bounced", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "recipient_type": "signer", "recipient_key": "client", "detail": "Permanent/General, diagnostic code: smtp; 550 5.1.1 As requested: user unknown" } } ``` ## recipient.failed Fires when an error prevents the invitation from being sent to a recipient. The recipient status changes to `failed`. The `data.detail` property contains a description of the failure, such as the recipient's email being on a blocklist. You may need to use the [Replace Recipient](/docs/api/resources/recipients/replace) endpoint to assign a different person. ```json JSON theme={null} { "id": "evt_7g8h9i0j1k2l3m4n5o6p", "type": "recipient.failed", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "recipient_type": "signer", "recipient_key": "client", "detail": "Recipient in email blocklist." } } ``` ## recipient.replaced Fires when a recipient is replaced through the [Replace Recipient](/docs/api/resources/recipients/replace) endpoint. The original recipient's status changes to `replaced`. The `data` object includes `new_recipient_id` and `new_recipient_name` identifying the replacement recipient. ```json JSON theme={null} { "id": "evt_8h9i0j1k2l3m4n5o6p7q", "type": "recipient.replaced", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "recipient_type": "signer", "recipient_key": "client", "new_recipient_id": "re_5SfFjI3eVfDokAXXDSjJlz", "new_recipient_name": "John Doe" } } ``` ## recipient.resent Fires when the invitation email is resent to a recipient via the [Resend Request](/docs/api/resources/recipients/resend) endpoint. The recipient status remains `sent`. ```json JSON theme={null} { "id": "evt_9i0j1k2l3m4n5o6p7q8r", "type": "recipient.resent", "timestamp": "2025-12-31T23:59:59.999Z", "data": { "object_id": "re_00ZeZjRaXCgT30n1eBx53N", "object_type": "recipient", "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "deal_id": "50055", "deal_owner": "Jane C." }, "recipient_type": "signer", "recipient_key": "client" } } ``` # Sender events Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/events/sender-events Track sender email verification lifecycle events including creation, verification, failure, and deletion Sender events track the lifecycle of email address verification for senders. Each event includes a `data` object with the sender's `object_id` and `email`. ## Event types | Event | When it fires | | ----------------- | -------------------------------------------------------- | | `sender.created` | A sender was created and the verification email was sent | | `sender.verified` | The address owner completed email verification | | `sender.failed` | Verification failed due to a bounce or error | | `sender.deleted` | A sender was deleted from the account | *** ## sender.created Fires when a new sender is created and the verification email is sent. The sender starts in `pending_verification` status. Listen for `sender.verified` or `sender.failed` to track the verification outcome. ```json JSON theme={null} { "id": "evt_yA80uuM4c90EbmxFuOC8Xv5", "type": "sender.created", "timestamp": "2025-01-01T00:00:00.000Z", "data": { "object_type": "sender", "object_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890", "email": "jennifer@example.com" } } ``` *** ## sender.verified Fires when a sender completes email verification. The sender status is now `verified`. SignatureAPI can send signing requests on behalf of this address. ```json JSON theme={null} { "id": "evt_yA80uuM4c90EbmxFuOC8Xv5", "type": "sender.verified", "timestamp": "2025-01-01T00:00:00.000Z", "data": { "object_type": "sender", "object_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890", "email": "jennifer@example.com" } } ``` *** ## sender.failed Fires when sender email verification fails. This can happen due to a soft or hard bounce of the verification email, or an internal error. The `data.detail` property contains a human-readable explanation of the failure reason. ```json JSON theme={null} { "id": "evt_yA80uuM4c90EbmxFuOC8Xv5", "type": "sender.failed", "timestamp": "2025-01-01T00:00:00.000Z", "data": { "object_type": "sender", "object_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890", "email": "jennifer@example.com", "detail": "Verification email bounced" } } ``` *** ## sender.deleted Fires when a sender is deleted from the account. SignatureAPI can no longer send signing requests on behalf of this address. ```json JSON theme={null} { "id": "evt_yA80uuM4c90EbmxFuOC8Xv5", "type": "sender.deleted", "timestamp": "2025-01-01T00:00:00.000Z", "data": { "object_type": "sender", "object_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890", "email": "jennifer@example.com" } } ``` # Boxed Text Input Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/places/boxed-text-input Collect structured data with individual character boxes for codes, SSN digits, or dates A **boxed text input place** displays a series of individual character boxes. Each box accepts one character, making this place type ideal for structured data such as verification codes, the last four digits of a Social Security Number, or date components. Boxed Text Input Boxed text input places are only available in envelopes with sequential signing. You can position boxed text input places using either [placeholders](/docs/api/resources/places/positioning/#placeholders) or [fixed positions](/docs/api/resources/places/positioning/#fixed-positions). ## Box Count The `box_count` property sets how many individual character boxes appear. Set this value based on the expected input length. | Use case | Recommended `box_count` | | ---------------------------- | ----------------------- | | Verification code (6 digits) | 6 | | Last 4 of SSN | 4 | | ZIP code | 5 | | Year (YYYY) | 4 | | Month or day (MM/DD) | 2 | ## Hints and Prompts Use `hint` and `prompt` to guide recipients while filling in the boxes. * **`hint`**: A tooltip shown when the recipient hovers over or focuses on the field. * **`prompt`**: Placeholder text displayed inside the first box. ```json theme={null} { //... "hint": "Enter the 6-digit code from your email", "prompt": "0" //... } ``` ## Capturing Input Set `capture_as` to store the entered value in the envelope's `captures` object. After the envelope is completed, retrieve the value using the key you specified. ## Size and Appearance * **`width`**: The total width of the field in points (1/72 inch). Must be between 30 and 540. Defaults to 30. * **`height`**: The height of each box in points (1/72 inch). Must be between 6 and 60. * **`font_size`**: The text size inside each box, in points. Must be between 6 and 12. Defaults to 12. ## Attributes Specifies the type of place. For a boxed text input place, the value must be `boxed_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The number of individual character boxes to display. Must be between 1 and 100. Each box accepts a single character from the recipient. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. A tooltip message displayed over the boxed text input field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). A placeholder message shown inside the first box during the signing ceremony to guide the recipient. Learn more in [Hints and Prompts](/docs/api/resources/places/boxed-text-input#hints-and-prompts). Specifies whether the recipient must fill all boxes to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. The total width of the boxed input field in points. Must be between 30 and 540. The default is 30. The height of each individual box in points. The font size in points. Must be between 6 and 12. The default is 12. ## Examples ```json Verification Code theme={null} "documents": [ { //... "places": [ { "key": "verification_code", "type": "boxed_text_input", "recipient_key": "signer", "font_size": 12, "width": 150, "height": 20, "box_count": 6, "capture_as": "verification_code", "hint": "Enter the 6-digit code from your email", "requirement": "required" } ] //... } ] ``` ```json Last 4 of SSN theme={null} "documents": [ { //... "places": [ { "key": "ssn_last_four", "type": "boxed_text_input", "recipient_key": "applicant", "font_size": 12, "width": 100, "height": 20, "box_count": 4, "capture_as": "ssn_last_four", "hint": "Last 4 digits of your Social Security Number", "requirement": "required" } ] //... } ] ``` ```json Tax ID (EIN) theme={null} "documents": [ { //... "places": [ { "key": "ein", "type": "boxed_text_input", "recipient_key": "taxpayer", "font_size": 12, "width": 225, "height": 20, "box_count": 9, "capture_as": "ein", "hint": "Enter your 9-digit Employer Identification Number", "requirement": "required" } ] //... } ] ``` # Checkbox Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/places/checkbox Add checkbox fields to documents for recipients to check during signing ceremonies A **checkbox place** marks a specific location in a document where a recipient checks or unchecks a box during the signing ceremony. Checkbox places are only available in envelopes with sequential signing. You can position checkbox places using either [placeholders](/docs/api/resources/places/positioning/#placeholders) or [fixed positions](/docs/api/resources/places/positioning/#fixed-positions). ## Symbol The `symbol` property controls what mark is shown when the box is checked. Use `check` for a checkmark (default) or `xmark` for an X. ## Requirement Set `requirement` to `required` to force the recipient to check the box before completing their action. Set it to `optional` to allow the recipient to skip it. ## Capturing Input Set `capture_as` to store whether the box was checked in the envelope's `captures` object. After the envelope is completed, retrieve the value using the key you specified. ## Size The `height` property sets the height of the checkbox in points (1/72 inch). The width equals the height. Must be between 8 and 40. Defaults to 20. ## Attributes Specifies the type of place. For a checkbox place, the value must be `checkbox`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The symbol to display in the checkbox when it is checked. Available options are `check` and `xmark`. The default is `check`. Specifies whether the recipient must check this box to complete the signing ceremony. Possible values are `required` or `optional`. The default is `optional`. The height of the checkbox in points. The width equals the height. Must be between 8 and 40. Defaults to 20. ## Examples ```json Basic (Optional) theme={null} "documents": [ { //... "places": [ { "key": "receive_marketing_emails", "type": "checkbox", "recipient_key": "employee", "symbol": "check", "height": 10 } ] //... } ] ``` ```json Required Checkbox theme={null} "documents": [ { //... "places": [ { "key": "accept_terms", "type": "checkbox", "recipient_key": "customer", "symbol": "check", "requirement": "required", "height": 12 } ] //... } ] ``` ```json X Symbol theme={null} "documents": [ { //... "places": [ { "key": "decline_arbitration", "type": "checkbox", "recipient_key": "customer", "symbol": "xmark", "height": 10 } ] //... } ] ``` ```json With Capture theme={null} "documents": [ { //... "places": [ { "key": "agreed_to_terms", "type": "checkbox", "recipient_key": "borrower", "symbol": "check", "requirement": "required", "capture_as": "terms_accepted", "height": 12 } ] //... } ] ``` # Date Places Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/places/date Automatically insert completion dates for individual recipients or the entire envelope Date places insert completion timestamps automatically at a specific location in a document. There are two types: one that records when a [specific recipient](#recipient-completed-date) completed their action, and one that records when [the entire envelope](#envelope-completed-date) was completed. You can position date places using either [placeholders](/docs/api/resources/places/positioning/#placeholders) or [fixed positions](/docs/api/resources/places/positioning/#fixed-positions). ## Date Format Both date place types accept a `date_format` property that controls how the date is rendered. Use [Moment.js format syntax](https://momentjs.com/docs/#/displaying/format/). The default format is `D MMM YYYY`, which renders as *31 Dec 2025*. Common formats: | Format string | Example output | | ------------------ | ----------------- | | `D MMM YYYY` | 31 Dec 2025 | | `YYYY-MM-DD` | 2025-12-31 | | `MM/DD/YYYY` | 12/31/2025 | | `MMMM D, YYYY` | December 31, 2025 | | `DD/MM/YYYY HH:mm` | 31/12/2025 14:30 | *** ## Recipient Completed Date A **recipient completed date** place records the date and time when the specific recipient identified by `recipient_key` completed their action on the envelope. ### Example ```json theme={null} "documents": [ { //... "places": [ { "key": "employer_signed_at", "type": "recipient_completed_date", "recipient_key": "employer", "date_format": "YYYY-MM-DD" } ] //... } ] ``` ### Attributes Specifies the type of place. For this kind of place, the value must be `recipient_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. The font size in points. Must be between 1 and 144. Defaults to 12. *** ## Envelope Completed Date An **envelope completed date** place records the date and time when the entire envelope was completed, meaning all recipients have finished their actions. This place type does not require a `recipient_key` because it applies to the envelope as a whole. ### Example ```json theme={null} "documents": [ { //... "places": [ { "key": "signed_by_all_at", "type": "envelope_completed_date", "date_format": "MM/DD/YYYY HH:mm" } ] //... } ] ``` ### Attributes Specifies the type of place. For this kind of place, the value must be `envelope_completed_date`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The date and time format using [Moment.js syntax](https://momentjs.com/docs/#/displaying/format/). Common formats include `D MMM YYYY` (31 Dec 2025), `YYYY-MM-DD` (2025-12-31), and `MM/DD/YYYY` (12/31/2025). Defaults to `D MMM YYYY`. The font size in points. Must be between 1 and 144. Defaults to 12. *** ## More Examples ```json ISO Format (YYYY-MM-DD) theme={null} "documents": [ { //... "places": [ { "key": "signed_date", "type": "recipient_completed_date", "recipient_key": "signer", "date_format": "YYYY-MM-DD" } ] //... } ] ``` ```json US Format (MM/DD/YYYY) theme={null} "documents": [ { //... "places": [ { "key": "completion_date", "type": "recipient_completed_date", "recipient_key": "client", "date_format": "MM/DD/YYYY" } ] //... } ] ``` ```json With Time (DD/MM/YYYY HH:mm) theme={null} "documents": [ { //... "places": [ { "key": "timestamp", "type": "envelope_completed_date", "date_format": "DD/MM/YYYY HH:mm" } ] //... } ] ``` ```json Long Format theme={null} "documents": [ { //... "places": [ { "key": "signed_on", "type": "recipient_completed_date", "recipient_key": "witness", "date_format": "MMMM D, YYYY" } ] //... } ] ``` # Dropdown Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/places/dropdown Add dropdown selection fields with predefined options for recipients to choose from A **dropdown place** marks a location in a document where a recipient selects one option from a predefined list during the signing ceremony. Dropdown Dropdown places are only available in envelopes with sequential signing. You can position dropdown places using either [placeholders](/docs/api/resources/places/positioning/#placeholders) or [fixed positions](/docs/api/resources/places/positioning/#fixed-positions). ## Options The `options` property defines the choices available in the dropdown. You can provide either custom options or a predefined option set. ### Custom options Supply an array of objects. Each object requires a `label` (displayed to the recipient) and accepts an optional `value` (stored when the option is selected). If `value` is omitted, `label` is used as the stored value. ```json theme={null} { //... "options": [ { "label": "Full-time", "value": "full_time" }, { "label": "Part-time", "value": "part_time" }, { "label": "Contract", "value": "contract" } ] //... } ``` ### Predefined option sets For common selections like countries or US states, use a predefined option set by specifying one of these string values: | Value | Description | Example values | | -------------------------------- | ------------------------ | ------------------------------------ | | `world_countries_names` | Full country names | "United States", "Canada", "Germany" | | `world_countries_2_letter_codes` | ISO 3166-1 alpha-2 codes | "US", "CA", "DE" | | `world_countries_3_letter_codes` | ISO 3166-1 alpha-3 codes | "USA", "CAN", "DEU" | | `world_countries_numeric_codes` | ISO 3166-1 numeric codes | "840", "124", "276" | | `us_states_names` | Full US state names | "California", "Texas", "New York" | | `us_states_2_letter_codes` | US state abbreviations | "CA", "TX", "NY" | ```json theme={null} { //... "options": "world_countries_names" //... } ``` ## Default Selection Use the `default` property to pre-select an option when the dropdown is displayed. The value is matched first against the `label` of each option, then against the `value`. If no match is found, a validation error is returned. ```json theme={null} { //... "options": "us_states_names", "default": "California" //... } ``` ## Behavior The `behavior` property controls how the dropdown is rendered during the signing ceremony. | Behavior | Description | | ---------------- | -------------------------------------------------------------------------------------------------------------- | | `auto` (default) | Renders as a standard dropdown for 10 or fewer options, and as a searchable combobox for more than 10 options. | | `select` | Always renders as a standard dropdown list. | | `combobox` | Always renders as a searchable dropdown with type-ahead filtering. | For large option sets like country lists, the `auto` behavior uses `combobox` since there are more than 10 options. ```json theme={null} { //... "options": "world_countries_names", "behavior": "combobox" //... } ``` ## Hints and Prompts Use `hint` and `prompt` to guide recipients while making their selection. * **`hint`**: A tooltip shown when the recipient hovers over or focuses on the dropdown. * **`prompt`**: Placeholder text shown inside the dropdown before a selection is made. ```json theme={null} { //... "hint": "Select your country of residence", "prompt": "Choose a country..." //... } ``` ## Capturing Input Set `capture_as` to store the selected value in the envelope's `captures` object. After the envelope is completed, retrieve the value using the key you specified. ## Size and Appearance * **`width`**: The width of the dropdown field in points (1/72 inch). Must be between 30 and 540. Defaults to 30. * **`font_size`**: The text size inside the dropdown, in points. Must be between 6 and 12. Defaults to 12. ## Attributes Specifies the type of place. For a dropdown place, the value must be `dropdown`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. Specifies the list of options available in the dropdown. You can provide either **custom options** or a **predefined option set**. **Custom options**: An array of objects, each with a `label` (displayed to the user) and an optional `value` (captured when selected). If `value` is omitted, the `label` is used as the value. ```json theme={null} "options": [ { "label": "Option A", "value": "a" }, { "label": "Option B", "value": "b" } ] ``` **Predefined options**: A string specifying a built-in option set: | Value | Description | | -------------------------------- | ----------------------------------------------- | | `world_countries_names` | Country names (e.g., "United States", "Canada") | | `world_countries_2_letter_codes` | ISO 3166-1 alpha-2 codes (e.g., "US", "CA") | | `world_countries_3_letter_codes` | ISO 3166-1 alpha-3 codes (e.g., "USA", "CAN") | | `world_countries_numeric_codes` | ISO 3166-1 numeric codes (e.g., "840", "124") | | `us_states_names` | US state names (e.g., "California", "Texas") | | `us_states_2_letter_codes` | US state codes (e.g., "CA", "TX") | Specifies the option that is pre-selected when the dropdown is displayed. The value is first matched against the `label` of each option. If no match is found, it is matched against the `value` of each option. If no match is found, a validation error is returned. Specifies the behavior of the dropdown during the signing ceremony. Possible values: * `auto` (default): Automatically selects the best behavior based on the number of options. Uses `select` for 10 or fewer options, and `combobox` for more than 10 options. * `select`: Displays a standard dropdown list. Best for short lists where users can quickly scan all options. * `combobox`: Displays a searchable dropdown with type-ahead filtering. Best for long lists where users need to search for their selection. Specifies whether the recipient must select an option to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. A placeholder message shown inside the dropdown field during the signing ceremony. Maximum length is 100 characters. Learn more in [Hints and Prompts](/docs/api/resources/places/dropdown#hints-and-prompts). A tooltip message displayed when the user hovers over or focuses on the dropdown field during the signing ceremony. Maximum length is 100 characters. Learn more in [Hints and Prompts](/docs/api/resources/places/dropdown#hints-and-prompts). A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. The font size in points. Must be between 6 and 12. The default is 12. The width of the dropdown field in points. Must be between 30 and 540. The default is 30. ## Examples ```json Custom Options theme={null} "documents": [ { //... "places": [ { "key": "employment_type", "type": "dropdown", "recipient_key": "employee", "options": [ { "label": "Full-time", "value": "full_time" }, { "label": "Part-time", "value": "part_time" }, { "label": "Contract", "value": "contract" }, { "label": "Internship", "value": "internship" } ], "default": "Full-time", "capture_as": "employment_type", "prompt": "Select employment type", "hint": "Choose the type of employment", "requirement": "required", "width": 150, "font_size": 10 } ] //... } ] ``` ```json Country Selection theme={null} "documents": [ { //... "places": [ { "key": "country_of_residence", "type": "dropdown", "recipient_key": "applicant", "options": "world_countries_names", "default": "United States", "behavior": "combobox", "capture_as": "country", "prompt": "Select your country", "hint": "Choose your country of residence", "requirement": "required", "width": 200, "font_size": 10 } ] //... } ] ``` ```json US State Selection theme={null} "documents": [ { //... "places": [ { "key": "state_selection", "type": "dropdown", "recipient_key": "customer", "options": "us_states_2_letter_codes", "capture_as": "state", "prompt": "Select state", "requirement": "required", "width": 80, "font_size": 10 } ] //... } ] ``` # Initials Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/places/initials Add initials fields to documents for recipients to place their initials during signing An **initials place** marks a specific location in a document where a recipient enters their initials. Each initials place is linked to one recipient through the `recipient_key`. A single recipient can have multiple initials places across different pages. You can position initials places using either [placeholders](/docs/api/resources/places/positioning/#placeholders) or [fixed positions](/docs/api/resources/places/positioning/#fixed-positions). The width of an initials place equals its height (a square field). ## Attributes Specifies the type of place. For an initials place, the value must be `initials`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the initials place in points. The width equals the height. Must be between 20 and 60. Defaults to 60. ## Examples ```json Basic (Placeholder) theme={null} "documents": [ { //... "places": [ { "key": "employer_initials", "type": "initials", "recipient_key": "employer", "height": 60 } ] //... } ] ``` ```json Fixed Position theme={null} "documents": [ { //... "places": [ { "key": "employer_initials", "type": "initials", "recipient_key": "employer", "height": 40 } ], "fixed_positions": [ { "place_key": "employer_initials", "page": 1, "top": 720, "left": 500 } ] //... } ] ``` ```json Initials on Multiple Pages theme={null} "documents": [ { //... "places": [ { "key": "client_initials_p1", "type": "initials", "recipient_key": "client", "height": 30 }, { "key": "client_initials_p2", "type": "initials", "recipient_key": "client", "height": 30 }, { "key": "client_initials_p3", "type": "initials", "recipient_key": "client", "height": 30 } ], "fixed_positions": [ { "place_key": "client_initials_p1", "page": 1, "top": 720, "left": 520 }, { "place_key": "client_initials_p2", "page": 2, "top": 720, "left": 520 }, { "place_key": "client_initials_p3", "page": 3, "top": 720, "left": 520 } ] //... } ] ``` ```json Compact Initials theme={null} "documents": [ { //... "places": [ { "key": "witness_initials", "type": "initials", "recipient_key": "witness", "height": 25 } ] //... } ] ``` # Multi-Line Text Input Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/places/multiline-text-input Collect longer text from recipients during signing with multi-line input fields A **multi-line text input place** marks a location in a document where a recipient enters text that spans multiple lines. Unlike [text input places](/docs/api/resources/places/text-input), which are single-line fields, multi-line text input places support multiple lines of text. Use them for comments, addresses, descriptions, or any input that may span several lines. Multi-line text input places are only available in envelopes with sequential signing. You can position multi-line text input places using either [placeholders](/docs/api/resources/places/positioning/#placeholders) or [fixed positions](/docs/api/resources/places/positioning/#fixed-positions). ## Hints and Prompts Use `hint` and `prompt` to guide recipients while they fill out the field. * **`hint`**: A tooltip shown when the recipient hovers over or focuses on the field. * **`prompt`**: Placeholder text displayed inside the field. It disappears when the recipient starts typing. ```json theme={null} { //... "hint": "Describe the reason for this request", "prompt": "Enter your comments here..." //... } ``` ## Capturing Input Set `capture_as` to store the entered value in the envelope's `captures` object. After the envelope is completed, retrieve the value using the key you specified. ## Size and Appearance * **`width`**: The width of the field in points (1/72 inch). Must be between 30 and 540. * **`line_count`**: The number of visible lines. Required. Must be between 1 and 100. * **`line_height`**: The vertical spacing between lines in points. Must be between 6 and 72. Must be greater than or equal to `font_size`. Defaults to 12. * **`font_size`**: The text size inside the field, in points. Must be between 6 and 12. Defaults to 12. ## Attributes Specifies the type of place. For a multi-line text input place, the value must be `multiline_text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/multiline-text-input#hints-and-prompts). Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. The width of the multi-line text input place in points. Must be between 30 and 540. The default is 30. The number of lines for the multi-line text input field. Must be between 1 and 100. The line height in points. Must be greater than or equal to `font_size`. Must be between 6 and 72. The default is 12. The font size in points. Must be between 6 and 12. The default is 12. ## Examples ```json Comments Field theme={null} "documents": [ { //... "places": [ { "key": "customer_comments", "type": "multiline_text_input", "recipient_key": "customer", "capture_as": "comments", "prompt": "Enter your comments here...", "hint": "Please provide detailed feedback", "requirement": "optional", "width": 400, "line_count": 5, "line_height": 14, "font_size": 10 } ] //... } ] ``` ```json Mailing Address theme={null} "documents": [ { //... "places": [ { "key": "full_address", "type": "multiline_text_input", "recipient_key": "applicant", "capture_as": "mailing_address", "prompt": "Enter your complete mailing address", "requirement": "required", "width": 350, "line_count": 3 } ] //... } ] ``` ```json Reason for Request theme={null} "documents": [ { //... "places": [ { "key": "request_reason", "type": "multiline_text_input", "recipient_key": "requester", "capture_as": "reason", "hint": "Describe why this request is needed", "requirement": "required", "width": 450, "line_count": 4, "font_size": 10 } ] //... } ] ``` # Place Object Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/places/object Define signature fields, input areas, and auto-filled values at specific locations in documents A **place** is a location on a document where a recipient performs an action or where information is displayed automatically. Places define where signatures go, where recipients type text, and where dates or names are inserted. Places are defined in the `places` array on a [document](/docs/api/resources/documents/object). Each element in the array represents one place within the document. The properties available on a place depend on its `type`. A place belongs to a [document](/docs/api/resources/documents/object). To generate a document from a template with dynamic data before any recipient signs, use [Document Templates](/docs/api/resources/documents/templates) instead. ## Place Types There are three categories of place: **signature** places for capturing signatures and initials, **interactive** places that require other input from a recipient, and **informational** places that insert values automatically. ### Signature places | Type | Description | | --------------------------------------------------- | -------------------------------------------- | | [`signature`](/docs/api/resources/places/signature) | The recipient draws or types their signature | | [`initials`](/docs/api/resources/places/initials) | The recipient enters their initials | ### Interactive places Interactive places require [sequential routing](/docs/api/resources/envelopes/routing). | Type | Description | | ------------------------------------------------------------------------- | --------------------------------------------------------- | | [`text_input`](/docs/api/resources/places/text-input) | The recipient types free-form text | | [`boxed_text_input`](/docs/api/resources/places/boxed-text-input) | The recipient enters text into individual character boxes | | [`multiline_text_input`](/docs/api/resources/places/multiline-text-input) | The recipient types text across multiple lines | | [`dropdown`](/docs/api/resources/places/dropdown) | The recipient selects from a list of options | | [`checkbox`](/docs/api/resources/places/checkbox) | The recipient checks or unchecks a box | ### Informational places | Type | Description | | -------------------------------------------------------------------------------------- | ----------------------------------------------------- | | [`text`](/docs/api/resources/places/text) | A static text value inserted on the document | | [`recipient_completed_date`](/docs/api/resources/places/date#recipient-completed-date) | The date the recipient completed their action | | [`envelope_completed_date`](/docs/api/resources/places/date#envelope-completed-date) | The date the envelope was completed by all recipients | | [`recipient_name`](/docs/api/resources/places/recipient-name) | The recipient's name | | [`recipient_email`](/docs/api/resources/places/recipient-email) | The recipient's email address | ## Positioning Every place must be positioned on the document. There are two ways to do this: * **Placeholder**: Embed `[[place_key]]` in the document text. The place appears where the placeholder is found. * **Fixed position**: Specify exact coordinates using page number, `top`, and `left` values measured in points (1 point = 1/72 inch). See [Place Positioning](/docs/api/resources/places/positioning) for details. ```json Signature theme={null} { "key": "employer_first_signature", "type": "signature", "recipient_key": "employer", "height": 60 } ``` ```json Initials theme={null} { "key": "employer_initials", "type": "initials", "recipient_key": "employer", "height": 60 } ``` ```json Text input theme={null} { "key": "buyer_email", "type": "text_input", "recipient_key": "buyer", "capture_as": "buyer_email", "prompt": "john@example.com", "hint": "Please enter your email", "format": "email", "requirement": "optional", "width": 200, "font_size": 8 } ``` ```json Boxed text input theme={null} { "key": "verification_code", "type": "boxed_text_input", "recipient_key": "signer", "font_size": 12, "width": 150, "height": 20, "box_count": 6, "capture_as": "verification_code", "hint": "Enter the 6-digit code from your email", "requirement": "required" } ``` ```json Multiline text input theme={null} { "key": "customer_comments", "type": "multiline_text_input", "recipient_key": "customer", "capture_as": "comments", "prompt": "Enter your comments here...", "hint": "Please provide detailed feedback", "requirement": "optional", "width": 400, "line_count": 5, "line_height": 14, "font_size": 10 } ``` ```json Dropdown theme={null} { "key": "employment_type", "type": "dropdown", "recipient_key": "employee", "options": [ { "label": "Full-time", "value": "full_time" }, { "label": "Part-time", "value": "part_time" }, { "label": "Contract", "value": "contract" }, { "label": "Internship", "value": "internship" } ], "default": "Full-time", "capture_as": "employment_type", "prompt": "Select employment type", "hint": "Choose the type of employment", "requirement": "required", "width": 150, "font_size": 10 } ``` ```json Checkbox theme={null} { "key": "receive_marketing_emails", "type": "checkbox", "recipient_key": "employee", "symbol": "check", "height": 10 } ``` ```json Text theme={null} { "key": "company_name", "type": "text", "value": "Lorem Ipsum Ltd", "font_size": 12, "font_color": "#000000" } ``` ```json Recipient completed date theme={null} { "key": "employer_signed_at", "type": "recipient_completed_date", "recipient_key": "employer", "date_format": "YYYY-MM-DD" } ``` ```json Envelope completed date theme={null} { "key": "signed_by_all_at", "type": "envelope_completed_date", "date_format": "MM/DD/YYYY HH:mm" } ``` ```json Recipient name theme={null} { "key": "client_name", "type": "recipient_name", "recipient_key": "client" } ``` ```json Recipient email theme={null} { "key": "client_email", "type": "recipient_email", "recipient_key": "client" } ``` # Place Positioning Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/places/positioning Position fields using text placeholders or fixed coordinates with page, x, and y values Every place must be positioned on a document. There are two methods: [placeholders](#placeholders) embedded in the document text, or [fixed positions](#fixed-positions) specified as coordinates. ### Placeholders A placeholder is a text string embedded directly in the document. Use the format `[[place_key]]`, where `place_key` matches the `key` of the corresponding place object. **`[[double brackets]]` vs `{{double curly braces}}`**: these serve different purposes: * `[[place_key]]`: **Place placeholders.** Position signature fields, text inputs, checkboxes, and other interactive places. Works in both PDF and DOCX documents. * `{{field_key}}`: **Template fields.** Inject dynamic content (names, dates, addresses) into the document text before signing. Only available in DOCX documents. See [Document Templates](/docs/api/resources/documents/templates). A DOCX document can use both: `{{}}` to inject content and `[[]]` to position places. For example, to define placeholders for two places with the keys `licensor_signs_here` and `licensor_signed_at`: Placeholder positioning When the envelope is processed, each placeholder is replaced by the rendered place. If `licensor_signs_here` is a `signature` place, the recipient's signature appears over the placeholder. If `licensor_signed_at` is a `recipient_completed_date` place, the date appears there instead. Placeholder positioning signed To hide placeholders from recipients, set the placeholder text color to white. Placeholder positioning signed white text ### Fixed Positions Fixed positions let you place a field at an exact location on a document page using coordinates. Specify the page number and the distances from the top (`top`) and left (`left`) edges of the page. Both `top` and `left` are measured in points (1 point = 1/72 inch) and can include decimal values. The coordinates reference the **bottom-left corner** of the place, as shown below. Fixed place positioning For example, to position a place with the key `employer_first_signature` at 1 inch from the left and 5 inches from the top of page 2: ```json theme={null} "documents": [ { //... "fixed_positions": [ { "place_key": "employer_first_signature", "page": 2, "top": 360, "left": 72 } ] //... } ] ``` ## Attributes The key of the place to position. Must match the `key` of a place in the document's `places` array. The page number where the place is positioned. Page numbering starts at 1. The vertical distance from the top edge of the page to the bottom-left corner of the place, in points (1/72 inch). Decimal values are allowed. The horizontal distance from the left edge of the page to the bottom-left corner of the place, in points (1/72 inch). Decimal values are allowed. ## Legacy Signature Places Earlier versions of SignatureAPI used placeholders like `[[employee.signature]]`, which are called [Legacy Signature Places](/docs/api/resources/places/signature-legacy). The current approach uses place objects with either placeholder or fixed position coordinates, as described above. Legacy signature places continue to work, and new projects should use the place objects approach. For Power Automate integration, legacy signature places are currently the only supported method. # Recipient Email Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/places/recipient-email Automatically insert the recipient's email address at a specific location in the document A **recipient email place** inserts the email address of the recipient identified by `recipient_key` at a specific location in the document. The value is inserted automatically and does not require any action from the recipient. You can position recipient email places using either [placeholders](/docs/api/resources/places/positioning/#placeholders) or [fixed positions](/docs/api/resources/places/positioning/#fixed-positions). ## Font Size Use `font_size` to control the size of the inserted text in points (1/72 inch). Must be between 1 and 144. Defaults to 12. ## Attributes Specifies the type of place. For this kind of place, the value must be `recipient_email`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The font size in points. Must be between 1 and 144. Defaults to 12. ## Examples ```json Basic (Placeholder) theme={null} "documents": [ { //... "places": [ { "key": "client_email", "type": "recipient_email", "recipient_key": "client" } ] //... } ] ``` ```json Fixed Position theme={null} "documents": [ { //... "places": [ { "key": "signer_email", "type": "recipient_email", "recipient_key": "signer" } ], "fixed_positions": [ { "place_key": "signer_email", "page": 1, "top": 200, "left": 150 } ] //... } ] ``` ```json Multiple Recipients theme={null} "documents": [ { //... "places": [ { "key": "buyer_email", "type": "recipient_email", "recipient_key": "buyer" }, { "key": "seller_email", "type": "recipient_email", "recipient_key": "seller" } ] //... } ] ``` ```json Custom Font Size theme={null} "documents": [ { //... "places": [ { "key": "applicant_email", "type": "recipient_email", "recipient_key": "applicant", "font_size": 10 } ] //... } ] ``` # Recipient Name Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/places/recipient-name Automatically insert the recipient's name at a specific location in the document A **recipient name place** inserts the name of the recipient identified by `recipient_key` at a specific location in the document. The value is inserted automatically and does not require any action from the recipient. You can position recipient name places using either [placeholders](/docs/api/resources/places/positioning/#placeholders) or [fixed positions](/docs/api/resources/places/positioning/#fixed-positions). ## Font Size Use `font_size` to control the size of the inserted text in points (1/72 inch). Must be between 1 and 144. Defaults to 12. ## Attributes Specifies the type of place. For this kind of place, the value must be `recipient_name`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The font size in points. Must be between 1 and 144. Defaults to 12. ## Examples ```json Basic (Placeholder) theme={null} "documents": [ { //... "places": [ { "key": "client_name", "type": "recipient_name", "recipient_key": "client" } ] //... } ] ``` ```json Fixed Position theme={null} "documents": [ { //... "places": [ { "key": "signer_name", "type": "recipient_name", "recipient_key": "signer" } ], "fixed_positions": [ { "place_key": "signer_name", "page": 1, "top": 180, "left": 150 } ] //... } ] ``` ```json Multiple Recipients theme={null} "documents": [ { //... "places": [ { "key": "buyer_name", "type": "recipient_name", "recipient_key": "buyer" }, { "key": "seller_name", "type": "recipient_name", "recipient_key": "seller" } ] //... } ] ``` ```json Custom Font Size theme={null} "documents": [ { //... "places": [ { "key": "employee_name", "type": "recipient_name", "recipient_key": "employee", "font_size": 10 } ] //... } ] ``` # Signature Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/places/signature Add signature fields to documents using fixed coordinates or text placeholders A **signature place** marks a specific location in a document where a recipient draws or types their signature. Each signature place is linked to one recipient through the `recipient_key`. A single recipient can have multiple signature places across different pages of a document. You can position signature places using either [placeholders](/docs/api/resources/places/positioning/#placeholders) or [fixed positions](/docs/api/resources/places/positioning/#fixed-positions). The width of a signature place is calculated automatically using a 5:2 ratio based on the `height`. ## Attributes Specifies the type of place. For a signature place, the value must be `signature`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. The height of the signature place in points. The width is calculated automatically using a 5:2 ratio based on this height. Must be between 20 and 60. Defaults to 60. ## Examples ```json Basic (Placeholder) theme={null} "documents": [ { //... "places": [ { "key": "employer_first_signature", "type": "signature", "recipient_key": "employer", "height": 60 } ] //... } ] ``` ```json Fixed Position theme={null} "documents": [ { //... "places": [ { "key": "employer_signature", "type": "signature", "recipient_key": "employer", "height": 60 } ], "fixed_positions": [ { "place_key": "employer_signature", "page": 2, "top": 360, "left": 72 } ] //... } ] ``` ```json Multiple Signatures (Same Recipient) theme={null} "documents": [ { //... "places": [ { "key": "employer_signature_page_1", "type": "signature", "recipient_key": "employer", "height": 60 }, { "key": "employer_signature_page_3", "type": "signature", "recipient_key": "employer", "height": 60 } ] //... } ] ``` ```json Compact Signature theme={null} "documents": [ { //... "places": [ { "key": "employee_signature", "type": "signature", "recipient_key": "employee", "height": 40 } ] //... } ] ``` ## Sizing guide The `height` property controls the signature field size in points. It must be between 20 and 60 (default: 60). The width is calculated automatically using a 5:2 ratio (width = height x 2.5). | Height | Width | Best for | | ------ | ----- | ------------------------------------ | | 20 | 50 | Tight layouts, small signature lines | | 40 | 100 | Compact documents with limited space | | 60 | 150 | Standard documents (default) | When using placeholders, the placeholder text (`[[place_key]]`) determines the position only. The rendered signature field uses the dimensions from the `height` property, not the size of the placeholder text. When using fixed positions, make sure the signature field fits within the page boundaries. A signature placed too close to the edge of a page may be clipped. # Text Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/places/text Insert static text strings at specific locations in documents before signing A **text place** inserts a static, read-only text value at a specific location in a document. It does not require any action from a recipient. The value is set when the envelope is created and cannot be changed by recipients. Text places are useful for pre-filling information such as company names, reference numbers, or contract dates before the signing process begins. Use text places with fixed positions to fill in PDF form fields before the first recipient signs. You can position text places using either [placeholders](/docs/api/resources/places/positioning/#placeholders) or [fixed positions](/docs/api/resources/places/positioning/#fixed-positions). ## Attributes Specifies the type of place. For a text place, the value must be `text`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The text content to display on the document. This is a static value set when the envelope is created and cannot be changed by the recipient. Maximum length is 1000 characters. The font size in points. Must be between 1 and 144. The default is 12. The font color for this text place. Must be a six-digit hex color code with a leading `#`. Defaults to `#000000` (black). ## Examples ```json Basic Text theme={null} "documents": [ { //... "places": [ { "key": "company_name", "type": "text", "value": "Lorem Ipsum Ltd", "font_size": 12, "font_color": "#000000" } ] //... } ] ``` ```json Pre-fill Date theme={null} "documents": [ { //... "places": [ { "key": "agreement_date", "type": "text", "value": "January 27, 2026", "font_size": 11 } ] //... } ] ``` ```json Large Header Text theme={null} "documents": [ { //... "places": [ { "key": "document_title", "type": "text", "value": "LOAN AGREEMENT", "font_size": 18, "font_color": "#000000" } ] //... } ] ``` ```json Colored Text theme={null} "documents": [ { //... "places": [ { "key": "account_number", "type": "text", "value": "ACC-2026-00142", "font_size": 10, "font_color": "#0066cc" } ] //... } ] ``` ```json Fixed Position (PDF Form Fill) theme={null} "documents": [ { //... "places": [ { "key": "customer_id", "type": "text", "value": "CUST-88421", "font_size": 10 } ], "fixed_positions": [ { "place_key": "customer_id", "page": 1, "top": 145, "left": 200 } ] //... } ] ``` # Text Input Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/places/text-input Collect information from recipients during signing with text input fields A **text input place** marks a location in a document where a recipient types free-form text during the signing ceremony. These serve the same purpose as form fields in other e-signature platforms. Text input places are only available in envelopes with sequential signing. You can position text input places using either [placeholders](/docs/api/resources/places/positioning/#placeholders) or [fixed positions](/docs/api/resources/places/positioning/#fixed-positions). ## Hints and Prompts Use `hint` and `prompt` to guide recipients while they fill out a text field. * **`hint`**: A tooltip shown when the recipient hovers over or focuses on the field. * **`prompt`**: Placeholder text displayed inside the field. It disappears when the recipient starts typing. ```json theme={null} { //... "hint": "Your 8-digit reference code", "prompt": "12345678" //... } ``` During the signing ceremony, the field appears like this: ## Format Validation The `format` property validates what the recipient can enter. You can use a predefined format or a custom regular expression. ### Predefined formats | Value | Description | | ------------ | ------------- | | `email` | Email address | | `zipcode-us` | US ZIP code | More predefined formats are coming. [Let us know](https://signatureapi.com/support) if you need a specific format. ### Custom regular expressions Wrap a regular expression in forward slashes to define a custom format. For example, to require exactly 8 numeric digits: ```json theme={null} { //... "format": "/^[0-9]{8}$/" //... } ``` ### Format messages Set `format_message` to show a custom message when the recipient's input does not match the required format. ```json theme={null} { //... "format": "/^[0-9]{8}$/", "format_message": "Must be exactly 8 numeric digits (0-9)" //... } ``` During signing, the message is displayed like this: ## Capturing Input Set `capture_as` to store the value the recipient enters in the envelope's `captures` object. After the envelope is completed, you can retrieve the value using the key you specified. ## Size and Appearance * **`width`**: The initial width of the field in points (1/72 inch). The field may expand beyond this width as the recipient types. * **`font_size`**: The text size inside the field, in points. Must be between 6 and 12. Defaults to 12. ## Attributes Specifies the type of place. For a text input place, the value must be `text_input`. A unique identifier for this place within the document. Use this key to match the place to its position, either through a `[[place_key]]` placeholder in the document or an entry in `fixed_positions`. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. The key of the recipient assigned to this place. Must match one of the `key` values in the envelope's `recipients` array. A key that stores the recipient's input in the envelope's `captures` object. When set, the value entered or selected by the recipient is saved under this key after the envelope is completed. Must start with a lowercase letter and contain only lowercase letters, numbers, and underscores. Maximum 32 characters. Set to `null` to disable capture. A tooltip message displayed over the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). A placeholder message shown inside the input text field during the signing ceremony. Learn more in [Hints and Prompts](/docs/api/resources/places/text-input#hints-and-prompts). Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. Defines the validation format for the user’s input. Accepted values: * `email` * `zipcode-us` * a custom regular expression, enclosed in `/`, for example: `/^[a-z0-9]{1,10}$/` Learn more in [Format Validation](/docs/api/resources/places/text-input#format-validation). The message displayed when the user’s input does not match the required format. Learn more in [Format Validation -> Adding a Custom Message](/docs/api/resources/places/text-input#adding-a-custom-message). The initial width of the text input field in points. The field may expand beyond this width during typing. Must be between 30 and 540. Defaults to 30. The font size in points. Must be between 6 and 12. Defaults to 12. ## Examples ```json Optional Email Field theme={null} "documents": [ { //... "places": [ { "key": "buyer_email", "type": "text_input", "recipient_key": "buyer", "capture_as": "buyer_email", "prompt": "john@example.com", "hint": "Please enter your email", "format": "email", "requirement": "optional", "width": 200, "font_size": 8 } ] //... } ] ``` ```json Required Reference Number theme={null} "documents": [ { //... "places": [ { "key": "reference_number", "type": "text_input", "recipient_key": "applicant", "capture_as": "ref_number", "prompt": "12345678", "hint": "Your 8-digit reference code", "format": "/^[0-9]{8}$/", "format_message": "Must be exactly 8 digits", "requirement": "required", "width": 120 } ] //... } ] ``` ```json Address Field (Wide) theme={null} "documents": [ { //... "places": [ { "key": "mailing_address", "type": "text_input", "recipient_key": "borrower", "capture_as": "borrower_address", "prompt": "123 Main St, City, State ZIP", "hint": "Enter your full mailing address", "requirement": "required", "width": 350, "font_size": 10 } ] //... } ] ``` ```json US ZIP Code theme={null} "documents": [ { //... "places": [ { "key": "zip_code", "type": "text_input", "recipient_key": "customer", "capture_as": "customer_zip", "prompt": "90210", "format": "zipcode-us", "requirement": "required", "width": 80 } ] //... } ] ``` # Approver Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/recipients/approver A recipient type who reviews and approves documents without adding a signature An **approver** is a recipient who reviews and approves documents without adding a signature. Approvers can fill in input places, but they cannot add signatures or initials. Use approvers for workflows that need a review or authorization step before the document reaches a signer. Common examples include: * Manager approval before a contract is sent to an external party * Compliance review before finalization * Internal sign-off where a formal signature is not required * Multi-stage approval workflows with different levels of authorization Approvers are functionally equivalent to [preparers](/docs/api/resources/recipients/preparer). The difference is in the wording shown during the ceremony. Approvers see "Approve" as the final action. Preparers see "Finish". ## Approver vs. signer | | Approver | Signer | | -------------------------- | ---------- | -------- | | Reviews documents | Yes | Yes | | Fills in input places | Yes | Yes | | Adds signature or initials | No | Yes | | Recorded in audit log | No | Yes | | Recipient type | `approver` | `signer` | Use an approver when someone needs to authorize a document without creating a signature record. Use a signer when a legally binding signature is required. ## The approver's ceremony The approver accesses the envelope through the **approver's ceremony**. The approver reviews the documents and fills in any input places assigned to them, such as text boxes or checkboxes. After completing all required actions, the approver clicks **Approve**. Approve button A confirmation screen appears once the approval is complete. Approved confirmation Approver actions are not recorded in the audit log. Only signer actions appear in the audit log attached to the deliverable. ## Workflow example Include an approver recipient before any signers in the recipient list. The approver reviews the documents and fills in any assigned input places. Recipients who act after the approver see the document with the approver's fields already filled in. Signers review the approved document and add their signatures. ## Creating an envelope with an approver Specify `"type": "approver"` for recipients who should review and approve without signing. Use sequential routing so the approver acts before the signer. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "recipients": [ { "key": "manager", "type": "approver", "name": "Sarah Chen", "email": "sarah@company.com" }, { "key": "client", "type": "signer", "name": "Michael Torres", "email": "michael@client.com" } ], "routing": "sequential", //... } ``` In this example, the manager reviews and approves the agreement first. Then the client receives the document to sign. ## Assigning places to an approver Approvers can fill in text inputs, checkboxes, and dropdowns. Assign places to an approver using the `recipient_key` property. Signature and initials places cannot be assigned to approvers. ```json theme={null} { "documents": [ { "places": [ { "type": "text_input", "recipient_key": "manager", "key": "approval_notes", //... }, { "type": "checkbox", "recipient_key": "manager", "key": "terms_reviewed", //... } ], //... } ], //... } ``` The values the approver enters are visible to recipients who act after them. ## Delivery The `delivery_type` defaults to `none` for approvers. SignatureAPI does not send an invitation email. Your application is responsible for sharing the ceremony URL with the approver. Set `delivery_type` to `email` if you want SignatureAPI to send the invitation automatically. ## Next steps * [Recipient lifecycle](/docs/api/resources/recipients/lifecycle) - Understand recipient status transitions * [Create a ceremony](/docs/api/resources/ceremonies/create) - Customize how the approver accesses the envelope * [Signer](/docs/api/resources/recipients/signer) - Add a recipient who signs documents * [Preparer](/docs/api/resources/recipients/preparer) - Add a recipient who fills in fields before signing * [Create an envelope](/docs/api/resources/envelopes/create) - Include approvers in a new envelope # Get a recipient Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/recipients/get GET /v1/recipients/{recipient_id} Retrieves the details of an existing recipient. Retrieves the details of a recipient, including their current status, ceremony information, and completion timestamp. Use this endpoint to check a recipient's progress through the signing workflow. The response includes the full recipient object for the recipient's type (signer, approver, or preparer). ### Path Parameters The unique identifier of the recipient. Recipient IDs use the `re_` prefix. ### Returns Returns a `200 OK` status code along with [a recipient object](/docs/api/resources/recipients/object) if successful, or an [error](/docs/api/errors) otherwise. ```json theme={null} // GET https://api.signatureapi.com/v1/recipients/{recipient_id} // X-API-Key: key_test_... ``` ```json Response theme={null} // HTTP Status 200 { "id": "re_26w2VVV5JVm4j459TY5BNM", "envelope_id": "52872f0e-b919-4d69-89cd-e7e56af00548", "type": "signer", "key": "client", "name": "Emily Johnson", "email": "emily@example.com", "status": "completed", "status_updated_at": "2025-12-31T15:00:00.000Z", "completed_at": "2025-12-31T15:00:00.000Z", "delivery_type": "email", "signature_options": ["typed", "drawn"], "ceremony": { "authentication": [ { "type": "email_link", "subject_override": null, "message_override": null } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": null }, "ceremony_creation": "automatic" } ``` # Recipient lifecycle Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/recipients/lifecycle Track recipient status through pending, awaiting, sent, completed, and other states The `status` property on a recipient indicates where the recipient is in the signing workflow. Status changes happen automatically as the envelope progresses. ## Status reference | Status | Description | | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `pending` | The envelope has not been sent to the recipient yet. This is the initial status when an envelope is created. | | `awaiting` | The recipient is waiting for one or more earlier recipients to complete. Applies to sequential routing only. | | `sent` | The invitation has been sent to the recipient. The recipient has not yet completed their ceremony. | | `completed` | The recipient has finished all required actions (for example, signed or approved). | | `rejected` | The recipient declined to complete the envelope. | | `soft_bounced` | The invitation email was temporarily undeliverable (for example, a full mailbox). You can resend the request using the [Resend](/docs/api/resources/recipients/resend) endpoint. | | `hard_bounced` | The invitation email was permanently undeliverable (for example, an invalid address). Use the [Replace](/docs/api/resources/recipients/replace) endpoint to assign a different recipient. | | `failed` | An error prevented the email from being sent. | | `replaced` | This recipient was replaced by a new one using the Replace endpoint. | ## Typical flow For an envelope with sequential routing and a single signer, the recipient moves through these statuses in order: 1. **`pending`** - The envelope is created. The recipient has been registered but not yet notified. 2. **`sent`** - The envelope starts processing and the invitation email is sent. 3. **`completed`** - The recipient finishes their ceremony. When an envelope has multiple recipients with sequential routing, later recipients wait in **`awaiting`** status until all earlier recipients complete. ## Handling delivery problems Two statuses indicate email delivery problems: **`soft_bounced`** means the email was temporarily rejected. The recipient's address may be valid. Use the [Resend](/docs/api/resources/recipients/resend) endpoint to try again. **`hard_bounced`** means the email was permanently rejected. The address is likely invalid. Use the [Replace](/docs/api/resources/recipients/replace) endpoint to assign a new recipient with a valid address. ## Monitoring status changes Listen for [recipient events](/docs/api/resources/events/recipient) to receive real-time notifications when a recipient's status changes. You can also poll the [Get a recipient](/docs/api/resources/recipients/get) endpoint to check the current status at any time. # Recipient Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/recipients/object The recipient object represents a person who participates in an envelope as a signer, approver, or preparer A **recipient** is a person who receives and acts on an envelope. Every envelope must have at least one recipient. Recipients have three types, each with a different role: | Type | Description | | --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- | | [Signer](/docs/api/resources/recipients/signer) | Reviews documents and adds a signature or initials. Every envelope must have at least one signer. | | [Approver](/docs/api/resources/recipients/approver) | Reviews and approves documents without signing. Approver actions are not recorded in the audit log. | | [Preparer](/docs/api/resources/recipients/preparer) | Fills in document fields before signers receive the envelope. Preparer actions are not recorded in the audit log. | Each recipient participates in the envelope through a **ceremony**, a guided session where they complete their assigned actions. A recipient's `status` tracks their progress through the workflow. See the [recipient lifecycle](/docs/api/resources/recipients/lifecycle) for details on each status and what triggers a transition. A recipient belongs to an [envelope](/docs/api/resources/envelopes/object). ## Attributes The unique identifier of the recipient. Recipient IDs use the `re_` prefix. The unique identifier of the envelope, in UUID format. The type of the recipient. Determines what actions the recipient can perform during the ceremony. | Type | Description | | ---------- | -------------------------------------------------------------- | | `signer` | Signs documents. Every envelope must have at least one signer. | | `approver` | Reviews and approves documents without signing. | | `preparer` | Fills in document fields on behalf of another party. | For signers, the type is `signer`. A unique identifier you assign to each recipient in the envelope. Use it to match recipients with the places they should interact with (such as signature fields) and to identify them in events and webhook notifications. The key must start with a lowercase letter. It can contain lowercase letters, numbers, and underscores. Maximum 32 characters. It must be unique within the envelope. The full name of the recipient. Appears in invitation emails and is pre-filled for typed signatures. The email address of the recipient. Used to send invitation emails when `delivery_type` is `email`. The current status of the recipient in the signing workflow. | Status | Description | | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | | `pending` | The envelope has not been sent to the recipient yet. This is the initial status. | | `awaiting` | The recipient is waiting for earlier recipients in the routing order to complete. | | `sent` | The invitation has been sent to the recipient. | | `completed` | The recipient has completed their required actions (for example, signed or approved). | | `rejected` | The recipient declined to complete the envelope. | | `soft_bounced` | The invitation email was temporarily undeliverable (for example, a full mailbox). You can resend the request. | | `hard_bounced` | The invitation email was permanently undeliverable (for example, an invalid address). Use the Replace endpoint to assign a new recipient. | | `failed` | An error occurred and the invitation could not be sent. | | `replaced` | This recipient was replaced with a new one via the Replace endpoint. | The current [ceremony](/docs/api/resources/ceremonies/object) for the recipient.
With **email link authentication**, the recipient receives an email with a direct link to the ceremony. Clicking the link authenticates the recipient and opens the signing session.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email link authentication, this value is `email_link`. The custom subject line used for this recipient's invitation email. `null` if the envelope title is used. The custom message body used for this recipient's invitation email. `null` if the envelope message is used.
With **email code authentication**, the recipient receives an email from SignatureAPI containing a 9-digit code. The recipient must enter this code to authenticate and access the ceremony.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email code authentication, this value is `email_code`.
With **custom authentication**, your application authenticates the recipient. SignatureAPI provides a ceremony URL that you share or embed in your application to give the recipient access.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For custom authentication, this value is `custom`. The name of your company or application that authenticated the recipient. This value appears in the envelope audit log as the authentication provider. Key-value pairs with metadata about the authentication event, such as timestamps, session IDs, and user identifiers. These values appear in the envelope audit log. The values in `data` must be sufficient to verify how the recipient was authenticated. You must retain all records needed to prove the recipient's authentication, such as session information. In cases such as legal proceedings, you may need to provide these records to confirm identity. Review our [Terms & Conditions](https://signatureapi.com/terms) for details.
An HTTPS URL to redirect the recipient to after the ceremony finishes. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The delay in seconds before the ceremony redirects to `redirect_url` (standalone ceremonies) or emits completion events (embedded ceremonies). Defaults to `3`. Allowed range: `0` to `20`. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The format of the ceremony URL. Available options: * `standard` (default): Full-length URL. Works for most use cases. * `short`: Shortened URL. Use this when sharing through space-constrained channels such as SMS or push notifications. Origins allowed to embed this ceremony in an iframe. These values set the `frame-ancestors` directive in the ceremony's Content Security Policy (CSP) header. Sources typically take the form of a scheme and host (for example, `https://app.example.com`). Wildcards are supported (for example, `https://*.example.com`). For all available options, see the [frame-ancestors documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors#sources). Defaults to an empty list (`[]`), which means embedding is not allowed. To allow embedding from all origins (not recommended for production), use `["*"]`. Only the origin (scheme and host) is used. Paths are ignored. The URL where the recipient can access the ceremony. You can share this link with the recipient directly or embed it in your application. This property is `null` when: * The ceremony uses `email_link` authentication. SignatureAPI delivers the URL by email in that case. * The ceremony is not active (for example, it is completed, revoked, or declined). The URL expires 30 days after creation, or when a new ceremony is created for the same recipient.
Controls whether the completed deliverable is automatically emailed to this recipient. | Value | Description | | ------- | ----------------------------------------------------------------------------------------------------------- | | `email` | The completed deliverable is delivered to this recipient by email. This is the default for signers. | | `none` | The completed deliverable is not emailed. Your application is responsible for distributing the deliverable. | The signature methods available to the signer. The first item in the array is shown as the default. | Option | Description | | ------- | ----------------------------------------------------------------------------------- | | `typed` | The signer types their name. It is pre-filled from the recipient's `name` property. | | `drawn` | The signer draws their signature using a mouse, stylus, or touchscreen. | If not specified, both `typed` and `drawn` are available, with `typed` shown first. The time at which the recipient completed their required actions on the envelope (for example, signed or approved), in ISO 8601 format. Returns `null` if the recipient has not yet completed. The time at which the recipient's status last changed, in ISO 8601 format. Updates whenever the recipient transitions to a new status.
How the ceremony is created for the recipient. Available options are `automatic` and `manual`. The default is `automatic`. This property is deprecated. Use the `ceremony` object on the recipient when creating an envelope to control ceremony creation. This property will continue to be supported for backwards compatibility.
The unique identifier of the recipient. Recipient IDs use the `re_` prefix. The unique identifier of the envelope, in UUID format. The type of the recipient. Determines what actions the recipient can perform during the ceremony. | Type | Description | | ---------- | -------------------------------------------------------------- | | `signer` | Signs documents. Every envelope must have at least one signer. | | `approver` | Reviews and approves documents without signing. | | `preparer` | Fills in document fields on behalf of another party. | For preparers, the type is `preparer`. A unique identifier you assign to each recipient in the envelope. Use it to match recipients with the places they should interact with (such as signature fields) and to identify them in events and webhook notifications. The key must start with a lowercase letter. It can contain lowercase letters, numbers, and underscores. Maximum 32 characters. It must be unique within the envelope. The full name of the recipient. Appears in invitation emails and is pre-filled for typed signatures. The email address of the recipient. Used to send invitation emails when `delivery_type` is `email`. The current status of the recipient in the signing workflow. | Status | Description | | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | | `pending` | The envelope has not been sent to the recipient yet. This is the initial status. | | `awaiting` | The recipient is waiting for earlier recipients in the routing order to complete. | | `sent` | The invitation has been sent to the recipient. | | `completed` | The recipient has completed their required actions (for example, signed or approved). | | `rejected` | The recipient declined to complete the envelope. | | `soft_bounced` | The invitation email was temporarily undeliverable (for example, a full mailbox). You can resend the request. | | `hard_bounced` | The invitation email was permanently undeliverable (for example, an invalid address). Use the Replace endpoint to assign a new recipient. | | `failed` | An error occurred and the invitation could not be sent. | | `replaced` | This recipient was replaced with a new one via the Replace endpoint. | The current [ceremony](/docs/api/resources/ceremonies/object) for the recipient.
With **email link authentication**, the recipient receives an email with a direct link to the ceremony. Clicking the link authenticates the recipient and opens the signing session.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email link authentication, this value is `email_link`. The custom subject line used for this recipient's invitation email. `null` if the envelope title is used. The custom message body used for this recipient's invitation email. `null` if the envelope message is used.
With **email code authentication**, the recipient receives an email from SignatureAPI containing a 9-digit code. The recipient must enter this code to authenticate and access the ceremony.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email code authentication, this value is `email_code`.
With **custom authentication**, your application authenticates the recipient. SignatureAPI provides a ceremony URL that you share or embed in your application to give the recipient access.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For custom authentication, this value is `custom`. The name of your company or application that authenticated the recipient. This value appears in the envelope audit log as the authentication provider. Key-value pairs with metadata about the authentication event, such as timestamps, session IDs, and user identifiers. These values appear in the envelope audit log. The values in `data` must be sufficient to verify how the recipient was authenticated. You must retain all records needed to prove the recipient's authentication, such as session information. In cases such as legal proceedings, you may need to provide these records to confirm identity. Review our [Terms & Conditions](https://signatureapi.com/terms) for details.
An HTTPS URL to redirect the recipient to after the ceremony finishes. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The delay in seconds before the ceremony redirects to `redirect_url` (standalone ceremonies) or emits completion events (embedded ceremonies). Defaults to `3`. Allowed range: `0` to `20`. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The format of the ceremony URL. Available options: * `standard` (default): Full-length URL. Works for most use cases. * `short`: Shortened URL. Use this when sharing through space-constrained channels such as SMS or push notifications. Origins allowed to embed this ceremony in an iframe. These values set the `frame-ancestors` directive in the ceremony's Content Security Policy (CSP) header. Sources typically take the form of a scheme and host (for example, `https://app.example.com`). Wildcards are supported (for example, `https://*.example.com`). For all available options, see the [frame-ancestors documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors#sources). Defaults to an empty list (`[]`), which means embedding is not allowed. To allow embedding from all origins (not recommended for production), use `["*"]`. Only the origin (scheme and host) is used. Paths are ignored. The URL where the recipient can access the ceremony. You can share this link with the recipient directly or embed it in your application. This property is `null` when: * The ceremony uses `email_link` authentication. SignatureAPI delivers the URL by email in that case. * The ceremony is not active (for example, it is completed, revoked, or declined). The URL expires 30 days after creation, or when a new ceremony is created for the same recipient.
Controls how the recipient receives the invitation to access the envelope. Also determines whether the completed deliverable is emailed to this recipient. | Value | Description | | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `email` | SignatureAPI sends an invitation email with the ceremony link. The completed deliverable is also delivered by email. | | `none` | No emails are sent. Your application is responsible for distributing the ceremony URL and the completed deliverable. This is the default for approvers and preparers. | The time at which the recipient completed their required actions on the envelope (for example, signed or approved), in ISO 8601 format. Returns `null` if the recipient has not yet completed. The time at which the recipient's status last changed, in ISO 8601 format. Updates whenever the recipient transitions to a new status.
How the ceremony is created for the recipient. Available options are `automatic` and `manual`. The default is `automatic`. This property is deprecated. Use the `ceremony` object on the recipient when creating an envelope to control ceremony creation. This property will continue to be supported for backwards compatibility.
The unique identifier of the recipient. Recipient IDs use the `re_` prefix. The unique identifier of the envelope, in UUID format. The type of the recipient. Determines what actions the recipient can perform during the ceremony. | Type | Description | | ---------- | -------------------------------------------------------------- | | `signer` | Signs documents. Every envelope must have at least one signer. | | `approver` | Reviews and approves documents without signing. | | `preparer` | Fills in document fields on behalf of another party. | For approvers, the type is `approver`. A unique identifier you assign to each recipient in the envelope. Use it to match recipients with the places they should interact with (such as signature fields) and to identify them in events and webhook notifications. The key must start with a lowercase letter. It can contain lowercase letters, numbers, and underscores. Maximum 32 characters. It must be unique within the envelope. The full name of the recipient. Appears in invitation emails and is pre-filled for typed signatures. The email address of the recipient. Used to send invitation emails when `delivery_type` is `email`. The current status of the recipient in the signing workflow. | Status | Description | | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | | `pending` | The envelope has not been sent to the recipient yet. This is the initial status. | | `awaiting` | The recipient is waiting for earlier recipients in the routing order to complete. | | `sent` | The invitation has been sent to the recipient. | | `completed` | The recipient has completed their required actions (for example, signed or approved). | | `rejected` | The recipient declined to complete the envelope. | | `soft_bounced` | The invitation email was temporarily undeliverable (for example, a full mailbox). You can resend the request. | | `hard_bounced` | The invitation email was permanently undeliverable (for example, an invalid address). Use the Replace endpoint to assign a new recipient. | | `failed` | An error occurred and the invitation could not be sent. | | `replaced` | This recipient was replaced with a new one via the Replace endpoint. | The current [ceremony](/docs/api/resources/ceremonies/object) for the recipient.
With **email link authentication**, the recipient receives an email with a direct link to the ceremony. Clicking the link authenticates the recipient and opens the signing session.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email link authentication, this value is `email_link`. The custom subject line used for this recipient's invitation email. `null` if the envelope title is used. The custom message body used for this recipient's invitation email. `null` if the envelope message is used.
With **email code authentication**, the recipient receives an email from SignatureAPI containing a 9-digit code. The recipient must enter this code to authenticate and access the ceremony.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For email code authentication, this value is `email_code`.
With **custom authentication**, your application authenticates the recipient. SignatureAPI provides a ceremony URL that you share or embed in your application to give the recipient access.
The type of authentication. Available values: `email_link`, `email_code`, and `custom`. For custom authentication, this value is `custom`. The name of your company or application that authenticated the recipient. This value appears in the envelope audit log as the authentication provider. Key-value pairs with metadata about the authentication event, such as timestamps, session IDs, and user identifiers. These values appear in the envelope audit log. The values in `data` must be sufficient to verify how the recipient was authenticated. You must retain all records needed to prove the recipient's authentication, such as session information. In cases such as legal proceedings, you may need to provide these records to confirm identity. Review our [Terms & Conditions](https://signatureapi.com/terms) for details.
An HTTPS URL to redirect the recipient to after the ceremony finishes. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The delay in seconds before the ceremony redirects to `redirect_url` (standalone ceremonies) or emits completion events (embedded ceremonies). Defaults to `3`. Allowed range: `0` to `20`. Learn more in [Redirect URL](/docs/api/resources/ceremonies/redirect-url). The format of the ceremony URL. Available options: * `standard` (default): Full-length URL. Works for most use cases. * `short`: Shortened URL. Use this when sharing through space-constrained channels such as SMS or push notifications. Origins allowed to embed this ceremony in an iframe. These values set the `frame-ancestors` directive in the ceremony's Content Security Policy (CSP) header. Sources typically take the form of a scheme and host (for example, `https://app.example.com`). Wildcards are supported (for example, `https://*.example.com`). For all available options, see the [frame-ancestors documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors#sources). Defaults to an empty list (`[]`), which means embedding is not allowed. To allow embedding from all origins (not recommended for production), use `["*"]`. Only the origin (scheme and host) is used. Paths are ignored. The URL where the recipient can access the ceremony. You can share this link with the recipient directly or embed it in your application. This property is `null` when: * The ceremony uses `email_link` authentication. SignatureAPI delivers the URL by email in that case. * The ceremony is not active (for example, it is completed, revoked, or declined). The URL expires 30 days after creation, or when a new ceremony is created for the same recipient.
Controls how the recipient receives the invitation to access the envelope. Also determines whether the completed deliverable is emailed to this recipient. | Value | Description | | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `email` | SignatureAPI sends an invitation email with the ceremony link. The completed deliverable is also delivered by email. | | `none` | No emails are sent. Your application is responsible for distributing the ceremony URL and the completed deliverable. This is the default for approvers and preparers. | The time at which the recipient completed their required actions on the envelope (for example, signed or approved), in ISO 8601 format. Returns `null` if the recipient has not yet completed. The time at which the recipient's status last changed, in ISO 8601 format. Updates whenever the recipient transitions to a new status.
How the ceremony is created for the recipient. Available options are `automatic` and `manual`. The default is `automatic`. This property is deprecated. Use the `ceremony` object on the recipient when creating an envelope to control ceremony creation. This property will continue to be supported for backwards compatibility.
```json Signer theme={null} // HTTP Status 200 { "id": "re_26w2VVV5JVm4j459TY5BNM", "envelope_id": "52872f0e-b919-4d69-89cd-e7e56af00548", "type": "signer", "key": "client", "name": "Emily Johnson", "email": "emily@example.com", "status": "completed", "status_updated_at": "2025-12-31T15:00:00.000Z", "completed_at": "2025-12-31T15:00:00.000Z", "delivery_type": "email", "signature_options": ["typed", "drawn"], "ceremony": { "authentication": [ { "type": "email_link", "subject_override": null, "message_override": null } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": null }, "ceremony_creation": "automatic" } ``` ```json Approver theme={null} // HTTP Status 200 { "id": "re_7KpQVVV5JVm4j459TY5ABC", "envelope_id": "52872f0e-b919-4d69-89cd-e7e56af00548", "type": "approver", "key": "manager", "name": "Sarah Chen", "email": "sarah@example.com", "status": "completed", "status_updated_at": "2025-12-31T14:30:00.000Z", "completed_at": "2025-12-31T14:30:00.000Z", "delivery_type": "none", "ceremony": { "authentication": [ { "type": "email_link", "subject_override": null, "message_override": null } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": null }, "ceremony_creation": "automatic" } ``` ```json Preparer theme={null} // HTTP Status 200 { "id": "re_9XtRVVV5JVm4j459TY5DEF", "envelope_id": "52872f0e-b919-4d69-89cd-e7e56af00548", "type": "preparer", "key": "sales_rep", "name": "Alex Smith", "email": "alex@example.com", "status": "completed", "status_updated_at": "2025-12-31T14:00:00.000Z", "completed_at": "2025-12-31T14:00:00.000Z", "delivery_type": "none", "ceremony": { "authentication": [ { "type": "email_link", "subject_override": null, "message_override": null } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": null }, "ceremony_creation": "automatic" } ``` # Preparer Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/recipients/preparer A recipient type who fills in document fields on behalf of other signers A **preparer** is a recipient who fills in document fields before the envelope reaches a signer. Preparers can complete text inputs, checkboxes, and dropdowns, but they cannot add signatures or initials. Use preparers when someone needs to populate document data before a signer receives the envelope. Common examples include: * A sales representative entering pricing, dates, or contract terms * An internal team member adding details visible to other recipients * An administrator collecting information separately from signatures Preparers are functionally equivalent to [approvers](/docs/api/resources/recipients/approver). The difference is in the wording shown during the ceremony. Preparers see "Finish" as the final action. Approvers see "Approve". ## The preparer's ceremony The preparer accesses the envelope through the **preparer's ceremony**. The preparer reviews the documents and fills in all input places assigned to them. These places may include: * Text input fields for names, dates, or other values * Checkboxes for selecting options * Other data entry fields defined in the document Text input After filling in all required places, the preparer clicks **Finish**. The envelope then proceeds to the next recipient. Prepared confirmation Preparer actions are not recorded in the audit log. Only signer actions appear in the audit log attached to the deliverable. ## Workflow example Include a preparer recipient before any signers in the recipient list. The preparer enters required information such as pricing, dates, or terms. Recipients who act after the preparer see the document with the preparer's fields already filled in. Signers review the document and add their signatures. ## Creating an envelope with a preparer Specify `"type": "preparer"` for recipients who should fill in fields before the signer receives the document. Use sequential routing so the preparer acts first. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Sales Agreement", "recipients": [ { "key": "sales_rep", "type": "preparer", "name": "Alex Smith", "email": "alex@company.com" }, { "key": "customer", "type": "signer", "name": "Jordan Lee", "email": "jordan@customer.com" } ], "routing": "sequential", //... } ``` In this example, the sales representative fills in the agreement details first. Then the customer receives the document to sign. With sequential routing, the preparer's input is visible to the signer. ## Assigning places to a preparer Assign places to a preparer using the `recipient_key` property. Preparers can fill in text inputs, checkboxes, and dropdowns. Signature and initials places cannot be assigned to preparers. ```json theme={null} { "documents": [ { "places": [ { "type": "text_input", "recipient_key": "sales_rep", "key": "contract_value", //... }, { "type": "signature", "recipient_key": "customer", //... } ], //... } ], //... } ``` ## Delivery The `delivery_type` defaults to `none` for preparers. SignatureAPI does not send an invitation email. Your application is responsible for sharing the ceremony URL with the preparer. Set `delivery_type` to `email` if you want SignatureAPI to send the invitation automatically. ## Next steps * [Recipient object](/docs/api/resources/recipients/object) - See all recipient properties * [Recipient lifecycle](/docs/api/resources/recipients/lifecycle) - Understand recipient status transitions * [Create a ceremony](/docs/api/resources/ceremonies/create) - Customize how the preparer accesses the envelope * [Approver](/docs/api/resources/recipients/approver) - Add a reviewer who approves without signing * [Envelope routing](/docs/api/resources/envelopes/routing) - Configure the order recipients act on the envelope # Replace a recipient Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/recipients/replace POST /v1/recipients/{recipient_id}/replace Replaces an existing recipient with a new one. Replaces a recipient with a new person. The original recipient's status changes to `replaced`, and a new recipient is created with the provided name and email. Use this endpoint when a recipient can no longer complete the envelope, for example after a hard bounce or if the wrong person was assigned. The new recipient inherits the original recipient's type, key, routing position, and assigned places. A new ceremony is created and the invitation is sent according to the recipient's `delivery_type`. Recipients can only be replaced if they have not completed yet and the envelope status is `processing` or `in_progress`. ### Path Parameters The unique identifier of the recipient. Recipient IDs use the `re_` prefix. ### Body Parameters The full name of the recipient. Appears in invitation emails and is pre-filled for typed signatures. The email address of the recipient. Used to send invitation emails when `delivery_type` is `email`. ### Returns Returns a `201 Created` status code along with the new [recipient object](/docs/api/resources/recipients/object) if successful, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/replace // X-API-Key: key_test_... // Content-Type: application/json { "name": "Jane Doe", "email": "jane@example.com" } ``` ```json Response theme={null} // HTTP Status 201 { "id": "re_8Unml6TyhNN8923Rminm40", "envelope_id": "52872f0e-b919-4d69-89cd-e7e56af00548", "type": "signer", "key": "client", "name": "Jane Doe", "email": "jane@example.com", "status": "pending", "status_updated_at": "2025-12-31T16:00:00.000Z", "completed_at": null, "delivery_type": "email", "signature_options": ["typed", "drawn"], "ceremony": { "authentication": [ { "type": "email_link", "subject_override": null, "message_override": null } ], "redirect_url": null, "redirect_delay": 3, "embeddable_in": [], "url_variant": "standard", "url": null }, "ceremony_creation": "automatic" } ``` # Resend request Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/recipients/resend POST /v1/recipients/{recipient_id}/resend Resends a signing request to the recipient. Resends the signing request to a recipient who has not yet completed their ceremony. Use this endpoint to: * **Send reminders.** If a recipient has not signed, resend the invitation as a reminder. * **Retry after a soft bounce.** If the invitation email was temporarily undeliverable, resend to try again. * **Re-deliver a lost email.** If a recipient reports not receiving the invitation, resend it. The resend is rate-limited to prevent email spam. The response includes `can_resend_at`, which tells you when the next resend can be initiated. The wait period increases with each attempt: | Attempts | Wait period | | -------- | ----------------------- | | 1-3 | 15 minutes | | 4-6 | 1 hour | | 7-10 | 24 hours | | Over 10 | No more resends allowed | The request can only be resent if the recipient's status is `sent` or `soft_bounced`, and the envelope status is `in_progress`. ### Path Parameters The unique identifier of the recipient. Recipient IDs use the `re_` prefix. ### Returns Returns a `200 OK` status code along with the following property: Time after which the next resend can be initiated, in ISO 8601 format. ```json Request theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/resend // X-API-Key: key_test_... ``` ```json Response theme={null} // HTTP Status 200 { "can_resend_at": "2025-12-31T22:00:00.000Z" } ``` # Signer Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/recipients/signer A recipient type who must add their signature or initials to complete the document A **signer** is a recipient who reviews documents and adds their signature or initials. Every envelope must have at least one signer. A signer's signature can serve different purposes depending on the document: * Create legal obligations * Serve as evidence of intent * Confirm knowledge and understanding * Authorize specific actions or commitments ## The signer's ceremony The signer interacts with the envelope through the **signer's ceremony**, a guided session where they complete all required signing actions. At the start of the ceremony, the signer must consent to using electronic signatures. This consent is legally required in most jurisdictions for electronic signatures to be valid. ![Consent screen](https://whimuc.com/QQDubRnfFPHF1uvj5mB5n8/fvhAEiNNi94cj.png) After consenting, the signer reviews the documents. If input places are assigned to the signer (such as text boxes or checkboxes), the signer fills them in. When ready, the signer clicks the place where their signature or initials is expected. ![Signature place](https://whimuc.com/QQDubRnfFPHF1uvj5mB5n8/6S9QW9w1uMpza9.png) The signer chooses how to sign: by typing their name or by drawing their signature. The signer adopts this symbol as their signature. ![Signature input](https://whimuc.com/QQDubRnfFPHF1uvj5mB5n8/Bj4WQGctPBjV4C.png) After completing all required places, the signer clicks **Finalize** to finish the ceremony. All steps of the signer's ceremony are recorded in the audit log. This log is attached to the signed documents in the deliverable. ![Audit log](https://whimuc.com/QQDubRnfFPHF1uvj5mB5n8/6NWAK3FDZCtqzS.png) ## Workflow example Include one or more signer recipients. Assign signature places to each signer. The signer receives an email invitation (if `delivery_type` is `email`) or accesses the ceremony URL directly. The signer consents to electronic signatures, reviews documents, fills in any input places, and adds their signature. Once all signers have finished, the envelope transitions to `completed` status and a deliverable is generated. ## Creating an envelope with a signer Specify `"type": "signer"` for recipients who must sign the document. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "recipients": [ { "key": "client", "type": "signer", "name": "Jordan Lee", "email": "jordan@example.com" } ], //... } ``` ## Assigning places to a signer Places are assigned to a signer using the `recipient_key` property. A signer must have at least one signature or initials place. Signers can also have text inputs, checkboxes, and other place types assigned. ```json theme={null} { "documents": [ { "places": [ { "type": "signature", "recipient_key": "client", "key": "client_signature", //... }, { "type": "text_input", "recipient_key": "client", "key": "client_title", //... } ], //... } ], //... } ``` ## Delivery type The `delivery_type` property controls whether the completed deliverable is automatically emailed to the signer. The default is `email`. Set `delivery_type` to `none` when your application distributes the signed documents itself. This is common when [embedding the ceremony in your web app](/docs/api/guides/how-to/embed-web) or [delivering signing links via SMS](/docs/api/guides/use-cases/sms-signing-link). ```json theme={null} { "recipients": [ { "type": "signer", "key": "client", "name": "Jordan Lee", "email": "jordan@example.com", "delivery_type": "none", //... } ], //... } ``` ## Signature options The `signature_options` array controls which signing methods are available. The first item in the array is shown as the default. | Option | Description | | ------- | ----------------------------------------------------------------------------------- | | `typed` | The signer types their name. It is pre-filled from the recipient's `name` property. | | `drawn` | The signer draws their signature using a mouse, stylus, or touchscreen. | Both options are enabled by default, with `typed` shown first. To allow only drawn signatures, set `signature_options` to `["drawn"]`. ## Next steps * [Recipient lifecycle](/docs/api/resources/recipients/lifecycle) - Understand recipient status transitions * [Create a ceremony](/docs/api/resources/ceremonies/create) - Customize how the signer accesses the envelope * [Approver](/docs/api/resources/recipients/approver) - Add a reviewer who approves without signing * [Preparer](/docs/api/resources/recipients/preparer) - Add a recipient who fills in fields before signing * [Create an envelope](/docs/api/resources/envelopes/create) - Include signers in a new envelope # Create a sender Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/senders/create POST /v1/senders Register a new sender email address and start the verification process Sender management via API is currently in public preview. To enable it, contact [support](https://signatureapi.com/support). Registers a new sender email address and starts the verification process. SignatureAPI sends a verification email to the provided address. The sender is returned with `pending_verification` status. Once the address owner clicks the confirmation link, the sender status changes to `verified`. The sender can then be used on envelopes. Listen for the [`sender.verified`](/docs/api/resources/events/sender-events#sender.verified) or [`sender.failed`](/docs/api/resources/events/sender-events#sender.failed) webhook events to track the outcome. ## Body parameters The email address to register as a sender. Must be a valid email address. Maximum 320 characters. ## Returns Returns a `201 Created` status code and [a sender object](/docs/api/resources/senders/object) on success, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // POST https://api.signatureapi.com/v1/senders // X-API-Key: key_test_... // Content-Type: application/json { "email": "jennifer@example.com" } ``` ```json Response theme={null} // 201 Created { "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890", "email": "jennifer@example.com", "status": "pending_verification", "created_at": "2025-01-01T00:00:00.000Z" } ``` # Delete a sender Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/senders/delete DELETE /v1/senders/{sender_id} Remove a sender email address from your account Sender management via API is currently in public preview. To enable it, contact [support](https://signatureapi.com/support). Deletes a [sender](/docs/api/resources/senders/object). Once deleted, the email address can no longer be used on new envelopes. Envelopes already sent using this sender are not affected. ## Path parameters The unique identifier of the sender. ## Returns Returns a `204 No Content` status code on success, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // DELETE https://api.signatureapi.com/v1/senders/a1b2c3d4-e5f6-7890-abcd-ef1234567890 // X-API-Key: key_test_... ``` ```json Response theme={null} // 204 No Content ``` # Get a sender Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/senders/get GET /v1/senders/{sender_id} Retrieve the details and current verification status of a sender Sender management via API is currently in public preview. To enable it, contact [support](https://signatureapi.com/support). Retrieves the details of a [sender](/docs/api/resources/senders/object). Use this endpoint to check the current verification status of a sender after creation. ## Path parameters The unique identifier of the sender. ## Returns Returns a `200 OK` status code and [a sender object](/docs/api/resources/senders/object) on success, or an [error](/docs/api/errors) otherwise. ```json Request theme={null} // GET https://api.signatureapi.com/v1/senders/a1b2c3d4-e5f6-7890-abcd-ef1234567890 // X-API-Key: key_test_... ``` ```json Response theme={null} // 200 OK { "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890", "email": "jennifer@example.com", "status": "verified", "created_at": "2025-01-01T00:00:00.000Z" } ``` # Sender Lifecycle Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/senders/lifecycle The verification lifecycle of a sender. When you create a sender, it starts in `pending_verification` status. SignatureAPI sends a verification email to the address. Once the address owner clicks the confirmation link, the status changes to `verified`. If the verification email bounces or an error occurs, the status changes to `failed`. Only senders with `verified` status can be assigned to envelopes. | Status | Description | | ---------------------- | ----------------------------------------------------------------------------------------- | | `pending_verification` | A verification email was sent. The address owner has not yet confirmed. | | `verified` | The address owner confirmed the verification email. This sender can be used on envelopes. | | `failed` | Verification failed due to a bounce or error. This sender cannot be used. | Subscribe to [`sender.verified`](/docs/api/resources/events/sender-events#sender-verified) or [`sender.failed`](/docs/api/resources/events/sender-events#sender-failed) webhook events to track the outcome. # Sender Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/senders/object A sender is a verified email address that SignatureAPI uses when sending signing requests to recipients A sender is a verified email address. SignatureAPI sends signing request emails to recipients on behalf of the sender's address. The sender's name, email address, and organization appear in every email sent to recipients, and the sender's address is used as the Reply-To address. Before an email address can be used as a sender, the address owner must complete email verification. SignatureAPI initiates this by sending a verification email when you create the sender. ## Verification lifecycle A sender goes through a verification process before it can be used. See the [sender lifecycle](/docs/api/resources/senders/lifecycle) for details. ## Managing senders You can manage senders in the [Dashboard](https://dashboard.signatureapi.com/settings/senders) under Settings, or programmatically using the API. Sender management via API is currently in public preview. To enable it, contact [support](https://signatureapi.com/support). **Dashboard.** When you created your SignatureAPI account, a sender was automatically added using your account email address. That sender is already verified. To add a new sender, click **New Sender** in the Senders settings and enter the email address to verify. **API.** Create a sender using the [Create a sender](/docs/api/resources/senders/create) endpoint. SignatureAPI sends the verification email automatically. Listen for the [`sender.verified`](/docs/api/resources/events/sender-events#sender.verified) or [`sender.failed`](/docs/api/resources/events/sender-events#sender.failed) webhook events to track the outcome. ## Default sender Every account has a default sender. When you create an envelope without specifying a sender, SignatureAPI uses the default sender's name and email. To change your account's default sender, click **Set default** next to the desired sender in the Dashboard. To specify a sender explicitly on an envelope, include the `sender` property in the request body: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Consulting Agreement", //... "sender": { "name": "Jennifer Lee", "email": "jennifer@example.com", "organization": "Acme Enterprises" } } ``` ## Email addresses in signing requests All signing request emails are sent from `noreply@signatureapi.com`. This cannot be changed. SignatureAPI enforces a strict DMARC policy to protect email deliverability across major email providers. Sending from custom domains would risk emails landing in spam or being rejected. Your verified sender address appears as the **Reply-To** address, so recipient replies go directly to you. The sender's name and organization also appear in the email body. To control the Reply-To address and sender details, [create and verify a sender](#managing-senders) with the desired email address, then assign it to envelopes or set it as your [default sender](#default-sender) or in the envelope request. Sending from a custom domain is available exclusively as part of the branding package for enterprise customers with very high monthly volumes. Set the From address using the [`envelope.branding.email.from`](/docs/api/resources/envelopes/object#param-from) property. Contact [support](https://signatureapi.com/support) to discuss eligibility. However, consider this could affect email deliverability and it's exclusive to premium enterprise customers. ## Attributes The unique identifier of the sender. The email address of the sender. SignatureAPI sends signing request emails to recipients on behalf of this address. The current verification status of the sender. | Status | Description | | ---------------------- | ----------------------------------------------------------------------------------------- | | `pending_verification` | A verification email was sent. The address owner has not yet confirmed. | | `verified` | The address owner confirmed the verification email. This sender can be used on envelopes. | | `failed` | Verification failed due to a bounce or error. This sender cannot be used. | The time at which the sender was created, formatted as an ISO 8601 timestamp. ```json Response theme={null} { "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890", "email": "jennifer@example.com", "status": "verified", "created_at": "2025-01-01T00:00:00.000Z" } ``` # Create an upload Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/uploads/create POST /v1/uploads Upload a PDF, DOCX, or PNG file to SignatureAPI and get back a URL to use as a document source. Upload a file to SignatureAPI for use as a document source in an envelope. Send the raw file bytes in the request body with the appropriate `Content-Type` header. The response includes a `url` property. Pass this value as the `url` property of a [document](/docs/api/resources/documents/object) when creating an envelope: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "documents": [ { "url": "https://api.signatureapi.com/v1/uploads/upl_1sAAaVfabdt0esVjmSTmLA", //... } ], //... } ``` Uploads created through this endpoint are temporary and expire 24 hours after creation. To store a file permanently for reuse across multiple envelopes, use the [Store Upload](/docs/api/resources/uploads/store) endpoint or upload it to your [Library](https://dashboard.signatureapi.com/library) in the dashboard. The Create Upload endpoint replaces the [Create File endpoint](/docs/api/resources/files/create). The File resource is soft-deprecated but remains available for backward compatibility. ## Request Send the raw file bytes as the request body. Set the `Content-Type` header to match the file format. | Content-Type | Format | | ------------------------------------------------------------------------- | ------ | | `application/pdf` | `pdf` | | `application/vnd.openxmlformats-officedocument.wordprocessingml.document` | `docx` | | `image/png` | `png` | Maximum file size: 5 MB (5,242,880 bytes). ```bash cURL theme={null} curl -X POST https://api.signatureapi.com/v1/uploads \ --data-binary "@/path/to/file.pdf" \ -H "Content-Type: application/pdf" \ -H "X-API-Key: key_test_..." ``` ```typescript TypeScript theme={null} import axios from "axios"; import * as fs from "fs"; async function uploadPdf() { const fileStream = fs.createReadStream("/path/to/file.pdf"); const response = await axios.post( "https://api.signatureapi.com/v1/uploads", fileStream, { headers: { "Content-Type": "application/pdf", "X-API-Key": "key_test_..." }, } ); console.log("Upload successful:", response.data); } uploadPdf(); ``` ```python Python theme={null} import requests with open("/path/to/file.pdf", "rb") as f: response = requests.post( "https://api.signatureapi.com/v1/uploads", headers={ "Content-Type": "application/pdf", "X-API-Key": "key_test_..." }, data=f ) print(response.json()) ``` ```ruby Ruby theme={null} require "net/http" require "uri" uri = URI("https://api.signatureapi.com/v1/uploads") File.open("/path/to/file.pdf", "rb") do |file| request = Net::HTTP::Post.new(uri) request["Content-Type"] = "application/pdf" request["X-API-Key"] = "key_test_..." request.body = file.read response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http| http.request(request) end puts response.body end ``` ```csharp C# theme={null} using System.Net.Http; using System.Net.Http.Headers; using var client = new HttpClient(); using var fileStream = File.OpenRead("/path/to/file.pdf"); var request = new HttpRequestMessage(HttpMethod.Post, "https://api.signatureapi.com/v1/uploads") { Content = new StreamContent(fileStream) }; request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/pdf"); request.Headers.Add("X-API-Key", "key_test_..."); var response = await client.SendAsync(request); Console.WriteLine(await response.Content.ReadAsStringAsync()); ``` ```java Java theme={null} import java.net.URI; import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.nio.file.Path; var client = HttpClient.newHttpClient(); var request = HttpRequest.newBuilder() .uri(URI.create("https://api.signatureapi.com/v1/uploads")) .header("Content-Type", "application/pdf") .header("X-API-Key", "key_test_...") .POST(HttpRequest.BodyPublishers.ofFile(Path.of("/path/to/file.pdf"))) .build(); var response = client.send(request, HttpResponse.BodyHandlers.ofString()); System.out.println(response.body()); ``` ```go Go theme={null} package main import ( "bytes" "fmt" "io" "net/http" "os" ) func main() { file, err := os.Open("/path/to/file.pdf") if err != nil { panic(err) } defer file.Close() data, err := io.ReadAll(file) if err != nil { panic(err) } req, err := http.NewRequest("POST", "https://api.signatureapi.com/v1/uploads", bytes.NewReader(data)) if err != nil { panic(err) } req.Header.Set("Content-Type", "application/pdf") req.Header.Set("X-API-Key", "key_test_...") client := &http.Client{} resp, err := client.Do(req) if err != nil { panic(err) } defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) } ``` File uploads must be made from your server, not from the browser. The API requires your API key in the request header, which must never be exposed to the client. If you need to accept files from users in the browser, upload the file to your own server first, then forward it to the SignatureAPI uploads endpoint. ## Returns Returns a `201 Created` status code and [an upload object](/docs/api/resources/uploads/object) on success, or an [error](/docs/api/errors) otherwise. ```bash Request theme={null} // POST https://api.signatureapi.com/v1/uploads // X-API-Key: key_test_... // Content-Type: application/pdf // ``` ```json PDF upload theme={null} // HTTP Status 201 { "id": "upl_1sAAaVfabdt0esVjmSTmLA", "retention": "temporary", "url": "https://api.signatureapi.com/v1/uploads/upl_1sAAaVfabdt0esVjmSTmLA", "format": "pdf", "sha_256": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", "size": 102400, "created_at": "2025-12-30T12:00:00.000Z", "expires_at": "2025-12-31T12:00:00.000Z" } ``` ```json DOCX upload theme={null} // HTTP Status 201 { "id": "upl_3joO7lxE8HVhOZmkCHFCxK", "retention": "temporary", "url": "https://api.signatureapi.com/v1/uploads/upl_3joO7lxE8HVhOZmkCHFCxK", "format": "docx", "sha_256": "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789", "size": 234567, "created_at": "2025-12-30T12:00:00.000Z", "expires_at": "2025-12-31T12:00:00.000Z" } ``` ```json PNG upload theme={null} // HTTP Status 201 { "id": "upl_7kBBcD2eF3gHiJkLmNoPqR", "retention": "temporary", "url": "https://api.signatureapi.com/v1/uploads/upl_7kBBcD2eF3gHiJkLmNoPqR", "format": "png", "sha_256": "fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210", "size": 51200, "created_at": "2025-12-30T12:00:00.000Z", "expires_at": "2025-12-31T12:00:00.000Z" } ``` # Retrieve an upload Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/uploads/get GET /v1/uploads/{uploadId} Retrieve the metadata for an existing upload by its ID. Retrieve the metadata for an existing upload. The response includes the file format, size, SHA-256 hash, retention type, and creation time. This endpoint returns upload metadata only. You cannot download the file content through the API. The Retrieve Upload endpoint replaces the [Get File endpoint](/docs/api/resources/files/get). The File resource is soft-deprecated but remains available for backward compatibility. ## Path Parameters The unique identifier of the upload. ## Returns Returns a `200 OK` status code and [an upload object](/docs/api/resources/uploads/object) on success, or an [error](/docs/api/errors) otherwise. ```bash Request theme={null} // GET https://api.signatureapi.com/v1/uploads/{uploadId} // X-API-Key: key_test_... ``` ```json Temporary upload theme={null} // HTTP Status 200 { "id": "upl_1sAAaVfabdt0esVjmSTmLA", "retention": "temporary", "url": "https://api.signatureapi.com/v1/uploads/upl_1sAAaVfabdt0esVjmSTmLA", "format": "pdf", "sha_256": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", "size": 102400, "created_at": "2025-12-30T12:00:00.000Z", "expires_at": "2025-12-31T12:00:00.000Z" } ``` ```json Permanent upload theme={null} // HTTP Status 200 { "id": "upl_3joO7lxE8HVhOZmkCHFCxK", "retention": "permanent", "key": "contract-template-v2", "url": "https://api.signatureapi.com/v1/uploads/upl_3joO7lxE8HVhOZmkCHFCxK", "format": "docx", "sha_256": "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789", "size": 234567, "created_at": "2025-12-30T12:00:00.000Z" } ``` # Upload Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/uploads/object Store PDF, DOCX, or PNG files in SignatureAPI and reference them as document sources in envelopes. An upload is a file stored in SignatureAPI. You can use an upload as the source file for a document in an envelope. Uploads are the simplest way to supply document files when you do not want to host them yourself. After uploading a file, pass the returned `url` value as the `url` property of a [document](/docs/api/resources/documents/object). The following file formats are supported: | Format | Media Type | | ------ | ------------------------------------------------------------------------- | | PDF | `application/pdf` | | DOCX | `application/vnd.openxmlformats-officedocument.wordprocessingml.document` | | PNG | `image/png` | ## Retention Uploads have one of two retention types, indicated by the `retention` property: | Retention | Description | | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Temporary | Created through the API. Automatically deleted 24 hours after creation. Use this for one-time document sends. | | Permanent | Stored indefinitely and reusable across multiple envelopes. Identified by a unique `key`. Created by [storing an upload](/docs/api/resources/uploads/store) through the API or uploading through the [Library](https://dashboard.signatureapi.com/library) in your dashboard. | The Upload resource replaces the [File resource](/docs/api/resources/files/object). The File resource is soft-deprecated but remains available for backward compatibility. ## Attributes The unique identifier of the upload. The retention type of the upload. | Value | Description | | ----------- | ------------------------------------------------------------------------------------------------------------------------------------ | | `temporary` | The file is automatically deleted 24 hours after creation. | | `permanent` | The file is stored indefinitely. Created by [storing an upload](/docs/api/resources/uploads/store) or through the dashboard library. | A unique identifier for the upload within your account. Present only on permanent uploads (`retention` is `permanent`). Only lowercase letters, numbers, hyphens, and underscores are allowed. Maximum 100 characters. The internal URL used to reference this upload in other API calls, such as `document.url`. You cannot use this URL to download the file directly. The file format of the upload. | Value | Description | | ------ | ---------------------------------------------------------------------------------------- | | `pdf` | A PDF file (`application/pdf`). | | `docx` | A DOCX file (`application/vnd.openxmlformats-officedocument.wordprocessingml.document`). | | `png` | A PNG image (`image/png`). | The SHA-256 hash of the uploaded file, in hexadecimal format. The size of the uploaded file in bytes. Maximum 5 MB (5,242,880 bytes). The date and time when the upload was created, in ISO 8601 format. The date and time when the upload will be automatically deleted, in ISO 8601 format. Present only on temporary uploads (`retention` is `temporary`). The expiration is 24 hours after creation. ```json Temporary upload theme={null} // HTTP Status Code 200 { "id": "upl_1sAAaVfabdt0esVjmSTmLA", "retention": "temporary", "url": "https://api.signatureapi.com/v1/uploads/upl_1sAAaVfabdt0esVjmSTmLA", "format": "pdf", "sha_256": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", "size": 102400, "created_at": "2025-12-30T12:00:00.000Z", "expires_at": "2025-12-31T12:00:00.000Z" } ``` ```json Permanent upload theme={null} // HTTP Status Code 200 { "id": "upl_3joO7lxE8HVhOZmkCHFCxK", "retention": "permanent", "key": "contract-template-v2", "url": "https://api.signatureapi.com/v1/uploads/upl_3joO7lxE8HVhOZmkCHFCxK", "format": "docx", "sha_256": "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789", "size": 234567, "created_at": "2025-12-30T12:00:00.000Z" } ``` # Store an upload Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/resources/uploads/store POST /v1/uploads/{uploadId}/store Convert a temporary upload into a permanent upload that does not expire. Convert a temporary upload into a permanent upload. The file is moved to permanent storage and no longer expires. A unique `key` is required to identify the permanent upload. Use this endpoint when you want to reuse a file across multiple envelopes without re-uploading it each time. For example, store a company logo or a contract template that you reference repeatedly. Once stored, the upload's `retention` changes from `temporary` to `permanent` and the `expires_at` property is removed. The upload `id` and `url` remain the same. ## Path Parameters The unique identifier of the upload to store. ## Body Parameters A unique identifier for the upload within your account. Only lowercase letters, numbers, hyphens, and underscores are allowed. Maximum 100 characters. ```json theme={null} // POST https://api.signatureapi.com/v1/uploads/{uploadId}/store // X-API-Key: key_test_... // Content-Type: application/json { "key": "acme-logo" } ``` ## Returns Returns a `200 OK` status code and [an upload object](/docs/api/resources/uploads/object) with `retention` set to `permanent`, or an [error](/docs/api/errors) otherwise. ```bash Request theme={null} // POST https://api.signatureapi.com/v1/uploads/{uploadId}/store // X-API-Key: key_test_... // Content-Type: application/json { "key": "contract-template-v2" } ``` ```json Response theme={null} // HTTP Status Code 200 { "id": "upl_1sAAaVfabdt0esVjmSTmLA", "retention": "permanent", "key": "contract-template-v2", "url": "https://api.signatureapi.com/v1/uploads/upl_1sAAaVfabdt0esVjmSTmLA", "format": "pdf", "sha_256": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", "size": 102400, "created_at": "2025-12-30T12:00:00.000Z" } ``` # Test Mode Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/test-mode Learn how to create safe, non-binding, test-mode envelopes When you sign up for SignatureAPI, you get a free test API key. Test API keys let you create test envelopes, great for trying out your workflows. ## Test envelopes don't send emails Don't be afraid of flooding your customer's inboxes with test emails. Emails from test envelopes don't get sent to recipients. But, you can inspect them in your [Dashboard's Email view](https://dashboard.signatureapi.com/emails?mode=test). Dashboard's Email View Where you can see the email contents: Email Detail ## Test envelopes are not legally-binding A notice watermark on documents in test envelopes makes them non-binding. Test Watermark ## Test envelopes are free We don't bill you for test envelopes. ## Test mode and live mode differences | | Test mode | Live mode | | --------------- | -------------------------------------------------------------------------------- | --------------------------- | | API key prefix | `key_test_` | `key_live_` | | Emails sent | No. Preview in [Dashboard](https://dashboard.signatureapi.com/emails?mode=test). | Yes, to real recipients. | | Legally binding | No. Documents show a watermark. | Yes. | | Billing | Free | Counted toward your plan. | | Webhooks | Delivered to test endpoints | Delivered to live endpoints | You can use test mode and live mode at the same time. They are independent: test envelopes, webhooks, and senders are separate from live ones. ## Switch to live mode When you are ready to start sending legally-binding envelopes, go to the API Key section of your [Dashboard](https://dashboard.signatureapi.com). Follow the instructions to create a live API key. Replace `key_test_` with your new `key_live_` key in your API calls. No other code changes are needed. # Webhooks Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/webhooks Learn how to receive events in your webhook endpoint Use webhooks to receive real-time events from your SignatureAPI account, so your backend can respond to these events and act accordingly. Receiving webhook events is useful for handling asynchronous events such as when a [recipient signs an envelope](/docs/api/resources/events/recipient-events#recipient-completed), an [envelope is completed](/docs/api/resources/events/envelope-events#envelope-completed), a [deliverable is generated](/docs/api/resources/events/deliverable-events#deliverable-generated), or an [email to a recipient bounces](/docs/api/resources/events/recipient-events#recipient-soft-bounced). ## Setting Up Webhooks You can receive events by registering a webhook endpoint in the [Dashboard](https://dashboard.signatureapi.com/settings/webhooks). You can register different webhook endpoints for [test or live](/docs/api/test-mode) events and select the [specific events](/docs/api/resources/events/envelope-events) to subscribe to for each endpoint.
Set up your webhook in the Dashboard
## Events When an event happens, SignatureAPI creates a new [Event object](/docs/api/resources/events/object). This is an example of an event object for a `recipient.completed` event: ```JSON theme={null} { "id": "evt_4p2oouvNvjp1I9ckgqycH2", "type": "recipient.completed", "timestamp": "2025-12-31T15:00:01.999Z", "data": { "envelope_id": "e387553d-cbb7-4924-abd8-b2d89699e9b5", "envelope_metadata": { "customer_ref": "x9550501", "account_annual_revenue": "$4,500,000" }, "object_id": "re_7v7Sion0vqjJioYmwfZ9mf", "object_type": "recipient", "recipient_type": "signer" } } ``` Learn more about the [different types of events](/docs/api/resources/events/envelope-events). ## Topic Filters If you want to use this feature, please contact support at [support@signatureapi.com](mailto:support@signatureapi.com) By default, SignatureAPI delivers events for all envelopes, whether in test or live mode. To receive events only for specific envelopes at a webhook endpoint, use **topic filters**. When creating an envelope, you can specify up to 10 topics in the `topics` array of the [Envelope object](/docs/api/resources/envelopes/object). Then, while setting up a webhook endpoint, list all the topics to receive events for those envelopes. ## Event Delivery SignatureAPI delivers the event via a `POST` request to your webhook endpoint, with the [Event object](/docs/api/resources/events/object) as the JSON payload. Delivery is successful if your endpoint responds with a status code in the `2XX` range (200 to 299). Any other status code means the delivery failed. SignatureAPI does not guarantee the order of event delivery, so your endpoint should be able to handle events arriving out of order. ## Retries If your endpoint responds with a status code outside the `2XX` range, SignatureAPI will keep trying to deliver the event for up to 48 hours, using an exponential backoff strategy. If delivery fails consistently for several days, we will notify the account owner and may temporarily disable deliveries to the endpoint. ## Authentication Webhook notifications are secured with an HMAC signature included in the `webhook-signature` header, following the [Standard Webhooks specification](https://github.com/standard-webhooks/standard-webhooks/blob/main/spec/standard-webhooks.md#verifying-webhook-authenticity). You can find the **Signing Secret** in the right column of the webhook endpoint definition:
Find your webhook's signing secret
Standard Webhooks provides SDKs to simplify webhook verification. For example, to verify signatures in [JavaScript or TypeScript](https://www.npmjs.com/package/standardwebhooks): ```JS theme={null} import { Webhook } from "standardwebhooks" const wh = new Webhook(signing_secret); wh.verify(webhook_payload, webhook_headers); ``` Libraries are available for the following languages: [JavaScript and TypeScript](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/javascript), [Python](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/python), [Java and Kotlin](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/java), [Rust](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/rust), [Go](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/go), [Ruby](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/ruby), [PHP](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/php), [C#](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/csharp), and [Elixir](https://github.com/standard-webhooks/standard-webhooks/tree/main/libraries/elixir). ## Source IPs If your webhook endpoint is behind a firewall, allow traffic from the following IP addresses: ``` 44.228.126.217 50.112.21.217 52.24.126.164 54.148.139.208 2600:1f24:64:8000::/56 ``` ## Tools These tools can be useful for testing webhooks: * [Webhook.site](https://webhook.site): Generates a random endpoint URL and lets you inspect POST requests sent to that endpoint. * [ngrok](https://ngrok.com/): Sets up a tunnel from an internet-facing endpoint to your local machine, allowing you to process webhooks locally. # SignatureAPI Docs Source: https://signatureapi-daf4ee54.mintlify.app/docs/api/welcome Integrate electronic signatures into your apps and workflows with SignatureAPI's REST API, no-code connectors, and embedded signing solutions Integrate electronic signatures into your apps and workflows with SignatureAPI. ## Get started Create your first envelope and send it for signature using the REST API. Build your first no-code signing workflow in Power Automate. ## What you can do Send to multiple signers in parallel or sequential order. Track every envelope from creation to completion. Fill templates with dynamic data to produce ready-to-sign documents. Add input fields, checkboxes, and dropdowns to capture data during signing. Embed the signing experience directly in your web or React Native app. Build no-code signing workflows connected to 1,000+ apps. Receive real-time updates when envelopes are signed, completed, or canceled. [See all capabilities](/docs/api/can_i) ## How it works An [envelope](/docs/api/resources/envelopes/object) holds your [documents](/docs/api/resources/documents/object) and [recipients](/docs/api/resources/recipients/object). Add documents directly as PDFs or generate them from [templates](/docs/api/resources/documents/templates). ```json expandable theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Dummy Consent", "documents": [ { "format": "pdf", "url": "https://pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/privacy-placeholder.pdf", "places": [ { "key": "signer_signs_here", "type": "signature", "recipient_key": "visitor" } ] } ], "recipients": [ { "type": "signer", "key": "visitor", "name": "John Doe", "email": "john@example.com" } ] } ``` Each recipient gets a link to review and sign. You can control the [signing order](/docs/api/resources/envelopes/routing) and [authenticate recipients](/docs/api/resources/ceremonies/authentication/overview) before they access the documents. Signing request email A [ceremony](/docs/api/resources/ceremonies/object) is the guided signing session where recipients review documents and complete their actions. Signing ceremony After all recipients complete their actions, SignatureAPI generates a [deliverable](/docs/api/resources/deliverables/object) containing the signed documents and an audit log. Audit log ## Explore Learn the core building blocks: envelopes, documents, recipients, ceremonies, and deliverables. Endpoints, authentication, test mode, pagination, and error handling. Try the API directly in your browser. Import our Postman collection and start exploring. Integrate the signing experience into your web or mobile app. Quick answers to common questions about SignatureAPI capabilities. # Manage API Keys Source: https://signatureapi-daf4ee54.mintlify.app/docs/dashboard/api-keys Create and manage API keys for your SignatureAPI account. API keys connect your application to your SignatureAPI account. Every request to the API requires a key, and the key determines whether the request runs in test mode or live mode. To manage your API keys, go to [Settings > API Keys](https://dashboard.signatureapi.com/settings/api-keys) in the Dashboard. API Keys page For technical details on how authentication works, see [Authentication](/docs/api/authentication). ## Test and live keys SignatureAPI provides two types of API keys: | Type | Prefix | Purpose | | :--- | :------------- | :------------------------------------------------------------- | | Test | `key_test_...` | Build and test your integration without sending real documents | | Live | `key_live_...` | Send legally binding documents in production | **Test keys** are free to use. Envelopes created with a test key don't send emails to recipients and are not legally binding. Use test keys while setting up your integration. **Live keys** create real envelopes that send emails and produce legally binding documents. Use live keys only when you're ready to go to production. ## Creating an API key You can only create live api keys after upgrading your account and adding a payment method. Go to [Settings > API Keys](https://dashboard.signatureapi.com/settings/api-keys) and click **Create API Key**. Enter a name or description to help you remember what this key is for. This is especially helpful if you have multiple keys. Create API key dialog The new key is displayed once. Copy it and store it in a safe place. You won't be able to see the full key again. ## Revoking an API key To revoke a key, go to [Settings > API Keys](https://dashboard.signatureapi.com/settings/api-keys), find the key you want to revoke, and click **Revoke**. Revoke an API key Revoking a key is permanent and takes effect immediately. Any application using that key will stop working. Existing envelopes are not affected. ## Keeping your keys safe * Never share API keys in public repositories, emails, or client-side code. * Store keys in environment variables or a secrets manager. * Use test keys during development and keep live keys restricted to production systems. * Revoke any key you suspect has been exposed and create a new one. You need the **Manage API keys** permission to create or revoke keys. See [Dashboard Users](/docs/dashboard/users) for details on roles and permissions. # Common Actions Source: https://signatureapi-daf4ee54.mintlify.app/docs/dashboard/common-actions Quick answers to frequently asked questions about the SignatureAPI Dashboard. ## Why did a recipient not receive their email? Go to [Emails](https://dashboard.signatureapi.com/emails) in the Dashboard, find the email, and open its detail page. The [Delivery report](/docs/dashboard/emails#delivery-report) section shows the SMTP response from the recipient's mail server — it tells you whether the email was delivered, bounced, or deferred, and the exact reason why. If the recipient's status is `soft_bounced`, you can [resend the invitation](/docs/api/resources/recipients/resend). If it is `hard_bounced`, you need to [replace the recipient](/docs/api/resources/recipients/replace) with a valid email address. ## How do I upload a file that does not expire? Upload it to the [Document Library](/docs/dashboard/library). Files uploaded through the Library are stored permanently and can be reused across multiple envelopes. Files uploaded through the [API](/docs/api/resources/uploads/create) are temporary and expire after 24 hours. ## How do I stop receiving email notifications? Go to [Settings > Notifications](https://dashboard.signatureapi.com/settings/notifications) and delete the [notification channel](/docs/dashboard/notification-channels) you want to remove. This stops all notification emails to that address immediately. Notification channels are separate from the emails sent to recipients — removing a channel does not affect signing request or completion emails sent to recipients. ## Why is my invoice higher after adding a team member? Each additional user beyond the account owner costs $0.65 per day (about $20 per month). The charge is prorated from the day the user was added. See [Manage Team Members](/docs/dashboard/users) for details on user roles and pricing. ## How do I download the signed document? Go to [Envelopes](https://dashboard.signatureapi.com/envelopes), find the completed envelope, and click **Download** on the [envelope detail page](/docs/dashboard/envelopes#envelope-actions). You can also download attachments from completion emails in the [Email Inspector](/docs/dashboard/emails#attachments). Programmatically, use the [Retrieve Deliverable](/docs/api/resources/deliverables/get) endpoint. ## How do I download the current state of an in-progress envelope? Open the in-progress envelope in the Dashboard and click **Download Current Version** in the Details section. This generates a PDF of the current state of the envelope, including any signatures collected so far. ## How do I cancel an envelope? Open the envelope in the Dashboard and click **Cancel**. Only envelopes with `in_progress` status can be canceled. This action is irreversible — recipients immediately lose access to the signing ceremony. You can also cancel programmatically using the [Cancel Envelope](/docs/api/resources/envelopes/cancel) endpoint. ## How do I change the Reply-To address on signing emails? Add and verify a new [sender](/docs/dashboard/senders) in the Dashboard, then set it as the default. You can also specify a different sender per envelope using the [`sender`](/docs/api/resources/senders/object) property when creating the envelope through the API. ## How do I use my company logo in emails? Upload your logo (PNG format) to the [Document Library](/docs/dashboard/library), copy the URL, and use it in the [`branding.logo`](/docs/api/resources/envelopes/branding#logos) property when creating an envelope. Only images uploaded to the Library can be used as logos. # Email Inspector Source: https://signatureapi-daf4ee54.mintlify.app/docs/dashboard/emails Preview and debug emails sent by SignatureAPI to recipients. The Emails page shows every email SignatureAPI sends on behalf of your account — signing requests, completion notices, and other [recipient](/docs/api/resources/recipients/object) notifications. Use it to preview email content, verify delivery, and debug bounces. To view your emails, go to [Emails](https://dashboard.signatureapi.com/emails) in the Dashboard. Emails list ## Test mode vs live mode Toggle **Test Mode** in the top-right corner to switch between test and live emails. **Test mode emails** are never sent to recipients. Instead, they appear in the Dashboard so you can preview the full email content, including ceremony links and access codes. This lets you test your integration end-to-end without sending real emails. Learn more about [Test Mode](/docs/api/test-mode). **Live mode emails** are sent to real recipients. The Dashboard shows the same email list, but ceremony links and access codes are obfuscated to protect the integrity of the signing ceremony. Only the recipient should have access to these values. ## Email details Click any email in the list to view its details. The detail page shows: * **Subject** — the email subject line * **To** — the recipient's name and email address * **From** — the sender name and `noreply@signatureapi.com` * **Reply To** — the verified [sender](/docs/dashboard/senders) email address * **Envelope** — the envelope title and ID * **Email Content** — a full preview of the email as the recipient would see it Email detail page ## Attachments Completion emails include an **Attachments** section where you can download the files that were sent with the email. Attachments section * **Deliverables** — the signed PDF documents generated after all recipients complete the envelope. Learn more about [deliverables](/docs/api/resources/deliverables/object). * **Attestation certificates** — included when the envelope uses a country-specific attestation standard such as [Mexico NOM-151](/docs/api/resources/envelopes/attestation). The certificate file is attached alongside the deliverable. Click **Download** next to any attachment to save it from the Dashboard. ## Delivery report Each email detail page includes a **Delivery** section with the SMTP report from the receiving mail server. Use this to debug delivery issues: * **Delivered** — the email was accepted by the recipient's mail server. * **Bounced** — the email was rejected. The SMTP response explains the reason (e.g., mailbox full, address not found). * **Deferred** — the email delivery was temporarily delayed. SignatureAPI retries automatically. Delivery report The SMTP report is especially useful when a recipient's status changes to [`soft_bounced`](/docs/api/resources/events/recipient-events#recipientsoft_bounced) or [`hard_bounced`](/docs/api/resources/events/recipient-events#recipienthard_bounced). It shows the exact response from the remote mail server, helping you identify whether the issue is a full mailbox, an invalid address, or a server-side block. You need the **Manage envelopes** permission to view emails. See [Manage Team Members](/docs/dashboard/users) for details on roles and permissions. # Browse Envelopes Source: https://signatureapi-daf4ee54.mintlify.app/docs/dashboard/envelopes View, filter, and manage envelopes from the Dashboard. The Envelopes page lists all [envelopes](/docs/api/resources/envelopes/object) in your account. Use it to monitor signing progress, inspect envelope details, and take actions like canceling or downloading [deliverables](/docs/api/resources/deliverables/object). To view your envelopes, go to [Envelopes](https://dashboard.signatureapi.com/envelopes) in the Dashboard. Envelopes list Toggle **Test Mode** in the top-right corner to switch between test and live envelopes. ## Filtering envelopes Use **Filter by status** to narrow the list to envelopes in a specific state: | Status | Description | | :---------- | :--------------------------------------------------------------------------------- | | Processing | The envelope is being prepared. Documents are validated and recipients are queued. | | In Progress | The envelope has been sent to recipients and is waiting for completion. | | Completed | All recipients have completed the envelope. A deliverable has been generated. | | Failed | An internal error occurred during processing. | | Canceled | The signing process was stopped before completion. | Learn more about the [envelope lifecycle](/docs/api/resources/envelopes/lifecycle). ## Envelope details Click any envelope in the list to view its full details. Envelope detail page The detail page is organized into the following sections: ### Details Shows the envelope's properties — created at, completed at, [sender](/docs/api/resources/senders/object), label, title, message, [language](/docs/api/resources/envelopes/language), [time zone](/docs/api/resources/envelopes/timezone), and [timestamp format](/docs/api/resources/envelopes/timestamp-format). On in progress envelopes, the **Details** section also includes the **Download Current Version** button, which lets you download a PDF of the current state of the envelope. This is useful for reviewing the documents and any signatures collected so far. ### Recipients Lists each [recipient](/docs/api/resources/recipients/object) with their name, key, type ([signer](/docs/api/resources/recipients/signer), [approver](/docs/api/resources/recipients/approver), or [preparer](/docs/api/resources/recipients/preparer)), current status, and the time their status last changed. ### Documents Lists the [documents](/docs/api/resources/documents/object) included in the envelope with their order, title, and page count. ### Emails Lists the emails sent for this envelope. Click any email to open it in the [Email Inspector](/docs/dashboard/emails) for full details, attachments, and delivery reports. ## Envelope actions The detail page provides action buttons depending on the envelope's status: * **Download** — download the [deliverable](/docs/api/resources/deliverables/object) PDF once the envelope is completed. Available on `completed` envelopes. * **Cancel** — permanently stop the signing process. Available on `in_progress` envelopes. This action is irreversible. See [Cancel an envelope](/docs/api/resources/envelopes/cancel). * **Delete** — remove the envelope from your account. Available on `completed`, `failed`, and `canceled` envelopes. You need the **Manage envelopes** permission to view and manage envelopes. See [Manage Team Members](/docs/dashboard/users) for details on roles and permissions. # General Settings Source: https://signatureapi-daf4ee54.mintlify.app/docs/dashboard/general-settings Configure default language, time zone, and timestamp format for your SignatureAPI account. The General Settings page sets account-wide defaults for language, time zone, and timestamp formatting. These defaults apply to every new envelope unless you override them with the [`language`](/docs/api/resources/envelopes/language), [`timezone`](/docs/api/resources/envelopes/timezone), or [`timestamp_format`](/docs/api/resources/envelopes/timestamp-format) properties when creating an envelope through the API. To update these settings, go to [Settings > General](https://dashboard.signatureapi.com/settings/general) in the Dashboard. General Settings page You need the **Manage account settings** permission to change general settings. ## Language The account language controls the default language for signing ceremonies, recipient email notifications, and the audit log in deliverables. Language setting Supported languages: | Language | API code | | :------------------- | :------- | | English | `en` | | Spanish | `es` | | French | `fr` | | German | `de` | | Italian | `it` | | Portuguese (Brazil) | `pt` | | Chinese (Simplified) | `zh` | | Hungarian | `hu` | To override this default for a specific envelope, set the [`language`](/docs/api/resources/envelopes/language) property when creating the envelope. ## Time zone The account time zone determines how timestamps appear in the deliverable's audit log. SignatureAPI uses [IANA Time Zone Database](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) identifiers (for example, `America/New_York` or `Europe/London`). Time zone setting The Dashboard detects your local time zone and shows a **Use this** shortcut to apply it. To override this default for a specific envelope, set the [`timezone`](/docs/api/resources/envelopes/timezone) property when creating the envelope. ## Timestamp format The timestamp format controls how dates and times are displayed in the deliverable's audit log. It combines a date format and a time format. Timestamp format setting **Date formats:** | Format | Example | | :----------- | :--------- | | `MM/DD/YYYY` | 12/31/2025 | | `DD/MM/YYYY` | 31/12/2025 | | `DD.MM.YYYY` | 31.12.2025 | | `DD-MM-YYYY` | 31-12-2025 | | `DD MM YYYY` | 31 12 2025 | | `YYYY-MM-DD` | 2025-12-31 | **Time formats:** | Format | Example | | :--------- | :---------- | | `HH:mm:ss` | 13:00:00 | | `hh:mm:ss` | 01:00:00 PM | | `HH.mm.ss` | 13.00.00 | | `hh.mm.ss` | 01.00.00 PM | To override this default for a specific envelope, set the [`timestamp_format`](/docs/api/resources/envelopes/timestamp-format) property when creating the envelope. # Upload Permanent Files Source: https://signatureapi-daf4ee54.mintlify.app/docs/dashboard/library Upload and manage permanent files for use as document sources in envelopes. The Library stores files permanently in your SignatureAPI account. Unlike [API uploads](/docs/api/resources/uploads/create) which expire after 24 hours, Library files are stored indefinitely and can be reused across multiple envelopes. The Library supports two types of files: * **Documents** (PDF, DOCX) — use as document sources in envelopes. Upload contracts, agreements, and other documents you send repeatedly. * **Images** (PNG, JPG) — use as logos for [envelope branding](/docs/api/resources/envelopes/branding). Only images uploaded to your Library can be used as logos. To manage your files, go to the [Library](https://dashboard.signatureapi.com/library) in the Dashboard. Library page For technical details on the upload resource, see the [Upload API reference](/docs/api/resources/uploads/object). ## Uploading a file Go to the [Library](https://dashboard.signatureapi.com/library) in the Dashboard. Click **Upload a file** or drag and drop a file into the upload area. Supported formats: | Format | Max size | | :----- | :------- | | PDF | 10 MB | | DOCX | 10 MB | | PNG | 10 MB | | JPG | 10 MB | Each file gets a unique key that identifies it within your account. The key appears in the file list and is part of the upload URL. You can edit the key by clicking the edit icon next to it. Keys can contain lowercase letters, numbers, hyphens, and underscores (max 100 characters). ## Using files from the Library Click **Copy URL** next to any file to copy its URL. How you use the URL depends on the file type. ### Documents in envelopes Use a PDF or DOCX URL as the `url` property of a [document](/docs/api/resources/documents/object) when creating an envelope: ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "documents": [ { "url": "https://api.signatureapi.com/v1/uploads/upl_7kWstHtxXmje18omrlV6OA#agreement-v1", "format": "pdf" //... } ], //... } ``` Learn more about the different ways to [provide document files](/docs/api/resources/documents/url). ### Images for branding Use a PNG URL as the `logo` property in [envelope branding](/docs/api/resources/envelopes/branding). The logo appears in the header of recipient emails and the signing ceremony. ```json theme={null} // POST https://api.signatureapi.com/v1/envelopes // X-API-Key: key_test_... // Content-Type: application/json { "title": "Service Agreement", "branding": { "logo": "https://api.signatureapi.com/v1/uploads/upl_3joO7lxE8HVhOZmkCHFCxK#company-logo" }, //... } ``` Only images uploaded to your Library can be used as logos. External URLs are not supported. ## Updating a file To replace a file with a new version, click **Update** on the Library page. The upload URL stays the same, so any envelope templates or integrations referencing that URL will automatically use the new version. ## Deleting a file To delete a file, click the actions menu (**...**) next to the file and select **Delete**. Deleting a file is permanent. Envelopes that were already created with the file are not affected, but the URL can no longer be used in new envelopes. ## Library vs API uploads | | Library (permanent) | API upload (temporary) | | :---------- | :----------------------------------------------- | :------------------------------------------------- | | Created via | Dashboard | [API endpoint](/docs/api/resources/uploads/create) | | Retention | Stored indefinitely | Expires after 24 hours | | Reusable | Yes — use the same URL across multiple envelopes | No — intended for one-time use | | Best for | Recurring documents, templates, logos | One-off sends from your application | You need the **Manage document library** permission to upload or delete files. See [Manage Team Members](/docs/dashboard/users) for details on roles and permissions. # Email Notifications Source: https://signatureapi-daf4ee54.mintlify.app/docs/dashboard/notification-channels Notification channels let you receive email updates about envelope and recipient activity in your account. When events occur (such as an envelope completing or a recipient bouncing), SignatureAPI sends a notification to each active channel. ## Adding a notification channel In the Dashboard, navigate to **[Settings > Notifications](https://dashboard.signatureapi.com/settings/notifications)**. Navigate to Settings > Notifications Click **New Notification Email** and enter the email address where you want to receive notifications. Click New Notification Email A verification email is sent to the address. Click the confirmation link to activate the channel. Verify the email address You need the **Manage Notifications Settings** permission to add or remove notification channels. ## Stop Receiving Notifications To delete a notification channel, go to **[Settings > Notifications](https://dashboard.signatureapi.com/settings/notifications)**, select the channel you want to remove, and delete it from the channel details page. Deleting a channel is permanent. The email address will stop receiving all notifications immediately, and you will need to re-add and re-verify it if you want to receive notifications at that address again. Notification channel details ## Channel statuses | Status | Description | | :------------------- | :--------------------------------------------------------------------------- | | Pending Verification | A verification email has been sent. Click the link in the email to activate. | | Active | The channel is verified and receiving notifications. | ## Notification events Active channels receive notifications for the following events: ### Envelope events | Event | Description | | :----------------- | :------------------------------------------ | | Envelope completed | All recipients have completed the envelope. | | Envelope canceled | The envelope was canceled. | | Envelope failed | The envelope has failed. | ### Recipient events | Event | Description | | :------------------ | :-------------------------------------------------------- | | Recipient completed | The recipient completed the ceremony. | | Recipient rejected | The recipient rejected the envelope. | | Recipient bounced | The email to the recipient bounced (soft or hard bounce). | | Recipient failed | The recipient's process failed. | ## Notification channels vs webhooks Notification channels send human-readable emails for monitoring purposes. For programmatic event handling, use [webhooks](/docs/api/webhooks) instead. # Dashboard Source: https://signatureapi-daf4ee54.mintlify.app/docs/dashboard/overview Manage envelopes, track signing status, configure settings, and view API keys in the SignatureAPI Dashboard. The [SignatureAPI Dashboard](https://dashboard.signatureapi.com) is where you manage your account, monitor envelopes, and configure settings. It works alongside the API — anything you configure in the Dashboard applies to envelopes created through the API, and envelopes created through the API appear in the Dashboard. ## Sections Browse envelopes, check signing progress, download deliverables, and cancel or delete envelopes. Preview emails sent to recipients, download attachments, and debug delivery issues with SMTP reports. Upload permanent files (PDF, DOCX, images) for reuse across envelopes and branding. ## Settings Set default language, time zone, and timestamp format for your account. Add and verify email addresses used as Reply-To in signing request emails. Receive email alerts when envelopes complete, fail, or recipients bounce. Invite team members and assign roles to control access to your account. Create and revoke test and live API keys for your integrations. Set up endpoints to receive real-time event notifications. # Manage Senders Source: https://signatureapi-daf4ee54.mintlify.app/docs/dashboard/senders Manage verified email addresses that appear in signing request emails. A sender is a verified email address that SignatureAPI uses when sending signing requests to recipients. The sender's name, email address, and organization appear in every email, and the sender's address is used as the Reply-To address so recipient replies go directly to you. To manage your senders, go to [Settings > Senders](https://dashboard.signatureapi.com/settings/senders) in the Dashboard. Senders settings page For technical details on the sender resource, see the [Sender API reference](/docs/api/resources/senders/object). ## Default sender Every account has a default sender. When you create an envelope without specifying a sender, SignatureAPI uses the default sender's name and email address. To change the default, click **Set default** next to the sender you want to use. To specify a different sender for a specific envelope, include the [`sender`](/docs/api/resources/senders/object) property when creating the envelope through the API. ## Adding a sender Go to [Settings > Senders](https://dashboard.signatureapi.com/settings/senders) and click **New Sender**. Enter the name, email address, and organization for the new sender. New sender dialog SignatureAPI sends a verification email to the address. The address owner must click the confirmation link to complete verification. When you created your SignatureAPI account, a sender was automatically added using your account email address. That sender is already verified. ## Sender statuses | Status | Description | | :------------------- | :--------------------------------------------------------------------------- | | Pending Verification | A verification email was sent. The address owner has not yet confirmed. | | Verified | The address owner confirmed the email. This sender can be used on envelopes. | | Failed | Verification failed due to a bounce or error. This sender cannot be used. | Only senders with **Verified** status can be assigned to envelopes. ## Removing a sender To remove a sender, go to [Settings > Senders](https://dashboard.signatureapi.com/settings/senders), select the sender, and delete it. You cannot delete the default sender — set a different sender as the default first. Sender detail page Removing a sender does not affect envelopes that were already sent using that address. ## How signing request emails work All signing request emails are sent from `noreply@signatureapi.com`. This cannot be changed — SignatureAPI enforces a strict DMARC policy to protect email deliverability. Your verified sender address appears as the **Reply-To** address, so recipient replies go directly to you. The sender's name and organization appear in the email body. You need the **Manage account senders** permission to add or remove senders. See [Dashboard Users](/docs/dashboard/users) for details on roles and permissions. # Manage Team Members Source: https://signatureapi-daf4ee54.mintlify.app/docs/dashboard/users Invite team members and assign roles to control access to your SignatureAPI account. The Team page lets you invite team members to your Dashboard and control what each person can access. Every user gets their own login credentials and a role that determines their permissions. To manage your team, go to [Settings > Team](https://dashboard.signatureapi.com/settings/team) in the Dashboard. Team settings page Your account includes one user (the account owner) at no extra cost. Each additional user costs $0.65 per day (about $20 per month). ## Inviting a team member Go to [Settings > Team](https://dashboard.signatureapi.com/settings/team) and click **Invite User**. Enter the team member's email address and select a role. Invite user dialog The invited user receives an email with instructions to join your account. They do not need an existing SignatureAPI account. You need the **Manage team** permission to invite or remove users. ## User roles Each user is assigned one role. The role controls which areas of the Dashboard and API the user can access. ### Owner Full access to everything. Every account has one owner. The owner role cannot be assigned to other users. ### Development Access to test-mode resources only. Use this role for developers building and testing integrations. * Manage envelopes, API keys, webhooks, API senders, and the document library in **test mode** ### Integration Access to both test and live resources. Use this role for developers who deploy and maintain integrations in production. * Everything in the Development role * Manage envelopes, API keys, webhooks, and API senders in **live mode** ### Operations Access to live envelopes only. Use this role for team members who monitor and manage envelopes in production but don't need developer tools. * Manage envelopes in **live mode** ### Billing Access to billing settings only. Use this role for team members who handle invoices and payment methods. * Manage billing ### Permissions reference For a full breakdown of permissions by role, see the matrix below. Permissions matrix by role ## Managing users To change a user's role or remove them from your account, go to [Settings > Team](https://dashboard.signatureapi.com/settings/team) and click on the actions of the user you want to manage. User detail page Removing a user revokes their access immediately. They can be re-invited later with the same or a different role. # Manage Webhooks Source: https://signatureapi-daf4ee54.mintlify.app/docs/dashboard/webhooks Set up webhook endpoints to receive real-time notifications when events happen in your account. Webhooks let your application receive automatic notifications when something happens in your SignatureAPI account — for example, when a recipient signs an envelope or a deliverable is generated. Instead of polling the API, SignatureAPI sends events directly to a URL you provide. To manage your webhooks, go to [Settings > Webhooks](https://dashboard.signatureapi.com/settings/webhooks) in the Dashboard. Webhooks settings page For technical details on event delivery, retries, and signature verification, see [Webhooks](/docs/api/webhooks). ## Adding a webhook endpoint Go to [Settings > Webhooks](https://dashboard.signatureapi.com/settings/webhooks) and click **New Webhook Endpoint**. Enter the URL where SignatureAPI should send events. This must be a publicly accessible HTTPS URL. New webhook endpoint form Choose which events you want to receive at this endpoint. You can subscribe to envelope events, recipient events, deliverable events, or sender events. See the full list of [available events](/docs/api/resources/events/envelope-events). Select whether this endpoint receives **test** events, **live** events, or both. Use test mode while building your integration, and add a live endpoint when you're ready for production. ## Signing secret Each webhook endpoint has a signing secret. Your application uses this secret to verify that incoming requests are genuinely from SignatureAPI. To find the signing secret, click on the endpoint in [Settings > Webhooks](https://dashboard.signatureapi.com/settings/webhooks). Webhook signing secret For instructions on verifying signatures in your code, see [Webhook Authentication](/docs/api/webhooks#authentication). ## Event types You can subscribe to events across four categories: ### [Envelope events](/docs/api/resources/events/envelope-events) | Event | Description | | :------------------- | :----------------------------------------------------------------- | | `envelope.created` | A new envelope was created | | `envelope.started` | The envelope finished processing and recipients are being notified | | `envelope.completed` | All recipients have completed the envelope | | `envelope.failed` | The envelope encountered an internal error | | `envelope.canceled` | The envelope was canceled | ### [Recipient events](/docs/api/resources/events/recipient-events) | Event | Description | | :----------------------- | :--------------------------------------------------- | | `recipient.released` | The recipient is ready to receive an invitation | | `recipient.sent` | The invitation email was sent | | `recipient.accessed` | The recipient opened the ceremony URL | | `recipient.viewed` | The recipient authenticated and viewed the documents | | `recipient.completed` | The recipient finished all required actions | | `recipient.rejected` | The recipient declined the envelope | | `recipient.soft_bounced` | The invitation email is temporarily undeliverable | | `recipient.hard_bounced` | The invitation email is permanently undeliverable | | `recipient.failed` | An error prevented the invitation from being sent | | `recipient.replaced` | The recipient was replaced with a new person | | `recipient.resent` | The invitation email was resent | ### [Deliverable events](/docs/api/resources/events/deliverable-events) | Event | Description | | :---------------------- | :---------------------------------------- | | `deliverable.generated` | The signed document is ready for download | | `deliverable.failed` | Document generation failed | ### [Sender events](/docs/api/resources/events/sender-events) | Event | Description | | :---------------- | :------------------------------------------------------- | | `sender.created` | A sender was created and the verification email was sent | | `sender.verified` | The sender completed email verification | | `sender.failed` | Sender verification failed | | `sender.deleted` | A sender was deleted from the account | ## Managing endpoints To edit or delete an endpoint, go to [Settings > Webhooks](https://dashboard.signatureapi.com/settings/webhooks) and click on the endpoint. Webhook endpoint detail You can update the URL, change the subscribed events, or delete the endpoint. Deleting an endpoint is permanent — SignatureAPI stops sending events to that URL immediately. ## Testing webhooks Use test-mode webhook endpoints while building your integration. Test events behave the same as live events but are triggered by envelopes created with a test API key. These tools can help you inspect and debug webhook deliveries: * **[Webhook.site](https://webhook.site)** — generates a temporary URL and shows every request sent to it. * **[ngrok](https://ngrok.com)** — creates a tunnel from a public URL to your local machine so you can process webhooks locally. You need the **Manage webhooks** permission to add or remove webhook endpoints. See [Dashboard Users](/docs/dashboard/users) for details on roles and permissions. # Ceremony Events Source: https://signatureapi-daf4ee54.mintlify.app/docs/embedded/ceremony-events Handle signing completion events via JavaScript messages or redirects in embedded ceremonies When an embedded ceremony reaches a terminal state, such as when the recipient signs the documents, it triggers an event. Your application should listen for these events and respond accordingly. For instance, you can close the iframe in a web app once the ceremony is complete. We offer two event delivery methods: Standard [JavaScript messages](#javascript-messages), ideal for web apps, and [redirects](#redirects), commonly used in mobile and native apps. ### Event types There are 3 types of ceremony events: | Event | Description | | -------------------- | --------------------------------------------------------------------------- | | `ceremony.completed` | The recipient has completed (for example signed) the envelope | | `ceremony.canceled` | The recipient has canceled the ceremony, for example by clicking the X icon | | `ceremony.failed` | An error happened and the ceremony can't be completed | For `ceremony.failed` events, the event includes an `error_type` and an `error_message` that explains the error: | Error Type | Error Message | | ------------------- | ---------------------------------------- | | `already_completed` | The ceremony has already been completed. | | `not_available` | The ceremony is no longer available. | | `unauthorized` | The ceremony URL is invalid | ### Event delivery We offer two ways to deliver the event from inside the ceremony to your application: | Delivery type | When to use | | ------------------- | ----------------------------------------------------------------------------- | | Javascript messages | Use this when embedding in web apps using ` ``` ## Testing with Embedder To help you test ceremony embedding before implementing it in your application, we provide an **Embedder** tool. This tool allows you to quickly preview how your ceremony will appear inside an iframe. Embedder tool interface showing ceremony URL input and iframe preview To use the embedder, follow these steps: 1. Go to the [Embedder Tool](https://signatureapi.github.io/embedder/) 2. Enter your [ceremony URL](/docs/api/resources/ceremonies/ceremony-url) (the `embedded=true` and `event_delivery=message` query parameters are added automatically) 3. Optionally, adjust the width and height values in pixels 4. The tool will display your ceremony in an iframe with the specified dimensions ## Listening to events The embedded ceremony sends JavaScript [MessageEvent](https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent)s for [events happening inside the ceremony](/docs/embedded/introduction#event-types). Your app can listen to these events and take actions, such as closing the iframe when the ceremony is completed. Here’s an example of how to listen to these events: ```js theme={null} // Function to handle the ceremony completed event function handleCeremonyCompleted(event) { console.log("Ceremony completed successfully."); } // Function to handle the ceremony canceled event function handleCeremonyCanceled(event) { console.log("Ceremony was canceled by the user."); } // Function to handle the ceremony failed event function handleCeremonyFailed(event) { const { error_type, error_message } = event.data; console.error(`Ceremony failed with error: ${error_type} - ${error_message}`); } // Function to handle incoming message events function handleMessage(event) { const { type } = event.data; switch (type) { case 'ceremony.completed': handleCeremonyCompleted(event); break; case 'ceremony.canceled': handleCeremonyCanceled(event); break; case 'ceremony.failed': handleCeremonyFailed(event); break; default: console.warn(`Unknown event type: ${type}`); } } // Add event listener to window for message events window.addEventListener('message', handleMessage, false); ``` ## Troubleshooting ### CSP frame-ancestors error If the browser refuses to load the iframe and you see an error like this in the console: > Refused to frame ... because an ancestor violates the following Content Security Policy directive: "frame-ancestors none". Check the following: * **`embedded=true` query parameter is present.** Without it, the correct CSP headers are not set and the browser blocks the iframe. * **`embeddable_in` is set correctly.** The array must include the exact origin where your app is hosted (for example, `https://app.example.com`). Include the protocol (`https://`) and omit trailing slashes or paths. * **Localhost testing.** Use `http://localhost:3000` (with your port number) in `embeddable_in` during development. * **Multiple origins.** If your app runs on multiple domains, include all of them in the `embeddable_in` array. To isolate the issue, you can temporarily set `embeddable_in` to `["*"]`: ```json theme={null} // POST https://api.signatureapi.com/v1/recipients/{recipient_id}/ceremonies // X-API-Key: key_test_... // Content-Type: application/json { "authentication": [ //... ], "embeddable_in": [ "*" ] } ``` Do not use the `*` wildcard in production. It allows any website to embed your signing ceremony, which is a security risk. # Add a document: PDF Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/add-document Adds a pdf document to an envelope. Before adding a document, you may have to add [placeholders](/docs/integrations/power-automate/places/place) for each signer. ### Input The file content of the document. Learn about some common [File Content sources](/docs/integrations/power-automate/documents/sources). The ID of the envelope to which the document will be added. The title of the document. It may be shown to recipients. Extra properties for extensibility. ### Output The ID of the document. # Add a document: DOCX Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/add-document-docx Adds a DOCX document to an envelope. Before adding a document, you may have to add [placeholders](/docs/integrations/power-automate/places/place) for each signer. ### Input The file content of the document. Learn about some common [File Content sources](/docs/integrations/power-automate/documents/sources). The ID of the envelope to which the document will be added. The title of the document. It may be shown to recipients. Extra properties for extensibility. ### Output The ID of the document. # Add a place: Envelope completed date Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/add-place-envelope-completed-date Adds a envelope completed date place to a document. ### Input A key that identifies this place within the document. The ID of the document to which the place will be added. Defines the format of the date and time. Refer to the documentation for allowed values. The page number to position this place. The distance (in points) from the top of the page to the bottom of the place. The distance (in points) from the left of the page to the place. Extra properties for extensibility. ### Output This action has no output. # Add a place: Initials Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/add-place-initials Adds an initials place to a document. ### Input A key that identifies this place within the document. A user-provided key that identifies a recipient within an envelope. It must be up to 32 alphanumeric, lowercase characters and must start with a letter. For example: `buyer`, `employee`, `party2` are valid recipient keys. The ID of the document to which the place will be added. Set a custom height, the width adjusts proportionally. The page number to position this place. The distance (in points) from the top of the page to the bottom of the place. The distance (in points) from the left of the page to the place. Extra properties for extensibility. ### Output This action has no output. # Add a place: Recipient completed date Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/add-place-recipient-completed-date Adds a recipient completed date place to a document. ### Input A key that identifies this place within the document. A user-provided key that identifies a recipient within an envelope. It must be up to 32 alphanumeric, lowercase characters and must start with a letter. For example: `buyer`, `employee`, `party2` are valid recipient keys. The ID of the document to which the place will be added. Defines the format of the date and time. Refer to the documentation for allowed values. The page number to position this place. The distance (in points) from the top of the page to the bottom of the place. The distance (in points) from the left of the page to the place. Extra properties for extensibility. ### Output This action has no output. # Add a place: Signature Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/add-place-signature Adds a signature place to a document. ### Input A key that identifies this place within the document. A user-provided key that identifies a recipient within an envelope. It must be up to 32 alphanumeric, lowercase characters and must start with a letter. For example: `buyer`, `employee`, `party2` are valid recipient keys. The ID of the document to which the place will be added. Set a custom height, the width adjusts proportionally. The page number to position this place. The distance (in points) from the top of the page to the bottom of the place. The distance (in points) from the left of the page to the place. Extra properties for extensibility. ### Output This action has no output. # Add a place: Text Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/add-place-text Adds a text place to a document. ### Input A key that identifies this place within the document. The value for this text place. The ID of the document to which the place will be added. The message displayed when the user’s input does not match the required format. The font size in points. The font color in hexadecimal notation. The page number to position this place. The distance (in points) from the top of the page to the bottom of the place. The distance (in points) from the left of the page to the place. Extra properties for extensibility. ### Output This action has no output. # Add a place: Text Input Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/add-place-text-input Adds a text input place to a document. ### Input A key that identifies this place within the document. A user-provided key that identifies a recipient within an envelope. It must be up to 32 alphanumeric, lowercase characters and must start with a letter. For example: `buyer`, `employee`, `party2` are valid recipient keys. The ID of the document to which the place will be added. A tooltip message shown over the input field for the recipient. A placeholder message shown inside the input text field during the signing ceremony. Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. A key that stores the recipient's input and is included in the envelope captures. Specifies the valid format for user input. Refer to the documentation for allowed values. The message displayed when the user’s input does not match the required format. The page number to position this place. The distance (in points) from the top of the page to the bottom of the place. The distance (in points) from the left of the page to the place. Extra properties for extensibility. ### Output This action has no output. # Add a recipient Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/add-recipient Adds a signer to an envelope. ### Input The name of the recipient. The email address of the recipient. A user-provided key that identifies a recipient within an envelope. It must be up to 32 alphanumeric, lowercase characters and must start with a letter. For example: `buyer`, `employee`, `party2` are valid recipient keys. The ID of the envelope to which the recipient will be added. How the ceremonies for a recipient are created. It can be `automatic`, where the recipient will be created the ceremony immediately and send via email, or `manual`, where the recipient will be created but the ceremony will be created later. How the deliverable is sent to the recipient. It can be `email`, where the recipient will receive an email with the deliverable, or `none`, where the recipient will not receive the deliverable. Extra properties for extensibility. ### Output The name of the recipient. The email address of the recipient. A user-provided key that identifies a recipient within an envelope. The ID of the recipient. How the ceremonies for a recipient are created. How the deliverable is sent to the recipient. # Add a template: DOCX Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/add-template Adds a DOCX template to an envelope. A template is a DOCX document with [fields and conditionals](/docs/integrations/power-automate/documents/document). You can fill the template using the [Add data to template](/docs/integrations/power-automate/actions/add-template-data) action. If you want to add signature places to the template check [signature places](/docs/integrations/power-automate/places/place). ### Input The file content of the template. Learn about some common [File Content sources](/docs/integrations/power-automate/documents/sources). The ID of the envelope to which the template will be added. The title of the document. It may be shown to recipients. Field: Value pair containing data to fill into the template. Extra properties for extensibility. ### Output The ID of the document. # Add data to template Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/add-template-data Adds data to a template. Use this action to add or merge data into a template. Before using this action, ensure you have [added a template to your envelope](/docs/integrations/power-automate/actions/add-template). ### Input The name of the field or condition into which the data will be merged. The value to be merged into the field or conditional. The ID of the document to which the place will be added. ### Output This action has no output. # Create a ceremony: Custom authentication Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/create-ceremony-custom Creates a ceremony where the recipient is authenticated externally to SignatureAPI. Use this to obtain a ceremony URL for sharing with recipients. ### Input The name of the authentication provider. This value is arbitrary and will appear in the audit logs of the envelope. Key: Value pair containing authentication metadata. These details will be included in the envelope's audit logs The ID of the recipient to which the ceremony will be created. A URL to redirect the recipient to after a ceremony is finished. [Learn more about ceremony redirect url](/docs/integrations/power-automate/recipients/redirect-url). Extra properties for extensibility. ### Output The URL the recipient must visit to initiate the ceremony # Create a ceremony: Email link authentication Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/create-ceremony-email-link Creates a ceremony where the recipient is authenticated via a link sent to their email. ### Input The ID of the recipient to which the ceremony will be created. A URL to redirect the recipient to after a ceremony is finished. [Learn more about ceremony redirect url](/docs/integrations/power-automate/recipients/redirect-url). Extra properties for extensibility. ### Output This action has no output. # Create an envelope Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/create-envelope Creates a new envelope to which you can add recipients and documents. ### Input The title of this envelope. This may be shown to recipients. A message to include in emails to recipients. Custom label given to the envelope for easier identification. Labels are for internal use and are not shown to recipients. The order in which recipients sign the envelope. It can be `parallel`, where all recipients can sign simultaneously, or `sequential`, where recipients sign one after another. The default language to be used in the signing ceremony and deliverables. If not specified, the account's default language is used. [Learn more about languages](/docs/integrations/power-automate/envelopes/language). The time zone to be used for timestamps in deliverables. The names should be the timezone identifiers in the IANA Time Zone Database. If not specified, the account's default timezone offset is used. [Learn more about time zones](/docs/integrations/power-automate/envelopes/timezone). The date and time format to be used in timestamps for deliverables. If not specified, the account's default timestamp format is used. [Learn more about time zones](/docs/integrations/power-automate/envelopes/timestamp-format). The name of the sender. This overrides the account default sender name. The name of the sender of the envelope. This overrides the account default sender email. Extra properties for extensibility. Envelope mode can be either `live` or `test`. In test mode, envelopes are non-binding, free, and do not send real emails. You can view these emails in the dashboard. Specifies the regulatory or compliance attestation applied to a completed envelope. Attestations are optional and used to ensure adherence to specific legal or regulatory standards. It can be `none` or `mx_nom151`. * mx\_nom151: To comply with Mexican NOM-151, which governs the preservation of data integrity, a *Constancia de Conservación* is generated for the Deliverable. Use to classify envelopes and filter webhook notifications. ### Output The title of the envelope. This may be shown to recipients. A message to include in emails to recipients. The name of the sender of the envelope. This overrides the account default sender name. The email address of the sender of the envelope. This overrides the account default sender email. The ID of the envelope. Whether the envelope is in `live` or `test` mode. Test mode envelopes are non-binding and not billed. Regulatory or compliance attestation. Use to classify envelopes and filter webhook notifications. Custom label given to the envelope for easier identification. Labels are for internal use and are not shown to recipients. The order in which recipients sign the envelope. It can be parallel, where all recipients can sign simultaneously, or sequential, where recipients sign one after another. The time zone to be used for timestamps in deliverables. The date and time format to be used in timestamps for deliverables. # Get a deliverable Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/get-deliverable Retrieves a deliverable using its ID. Use it to download a signed copy of the envelope. ### Input The ID of the deliverable. ### Output The ID of the deliverable. The type of the deliverable. Currently, the only type is `audit_log`. The current status of the deliverable. Available options are `processing`, `generated`, and `failed`. The file content of the deliverable. Use this as input in a downstream action to save the signed document. # Get an envelope Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/get-envelope Retrieves the details of an envelope. ### Input The ID of the envelope. ### Output The title of the envelope. This may be shown to recipients. A message to include in emails to recipients. The email address of the sender of the envelope. This overrides the account default sender email. The name of the sender of the envelope. This overrides the account default sender name. The [current status](/docs/integrations/power-automate/envelopes/envelope#lifecycle) of the envelope. Available options: `draft`, `processing`, `in_progress`, `completed`, `failed`, `canceled`. The ID of the deliverable. If the deliverable is not generated, this value will be null. Make sure the deliverable is generated by adding a [Wait for envelope](/docs/integrations/power-automate/actions/wait-envelope) action before this action. The ID of the envelope. Time at which the envelope was completed by all recipients, in ISO 8601 format. Whether the envelope is in `live` or `test` mode. Test mode envelopes are non-binding and not billed. Regulatory or compliance attestation. Use to classify envelopes and filter webhook notifications. Custom label given to the envelope for easier identification. Labels are for internal use and are not shown to recipients. The order in which recipients sign the envelope. It can be `parallel`, where all recipients can sign simultaneously, or `sequential`, where recipients sign one after another. The time zone to be used for timestamps in deliverables. The date and time format to be used in timestamps for deliverables. # Get a recipient Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/get-recipient Retrieves recipient details by their ID. ### Input The ID of the envelope. ### Output A user-provided key that identifies a recipient within an envelope. The name of the recipient. The email address of the recipient. The ID of the recipient. The ID of the envelope. The type of the recipient. The status of the recipient. Available options are `pending`, `sent`, `completed`, `rejected`, `soft_bounced`, `hard_bounced`, `failed`, and `replaced`. Time when the recipient completed the envelope. How the ceremonies for a recipient are created. How the deliverable is sent to the recipient. # Start an envelope Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/start-envelope Initiates the signing process for an envelope. ### Input The ID of the envelope. ### Output The [current status](/docs/integrations/power-automate/envelopes/envelope#lifecycle) of the envelope. Available options: `draft`, `processing`, `in_progress`, `completed`, `failed`, `canceled`. # Wait for envelope Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/actions/wait-envelope Waits for an envelope to reach a completed state or another final status. ### Input The ID of the envelope. ### Output The title of the envelope. This may be shown to recipients. A message to include in emails to recipients. The email address of the sender of the envelope. This overrides the account default sender email. The name of the sender of the envelope. This overrides the account default sender name. The [current status](/docs/integrations/power-automate/envelopes/envelope#lifecycle) of the envelope. Available options: `draft`, `processing`, `in_progress`, `completed`, `failed`, `canceled`. The ID of the deliverable. If the deliverable is not generated, this value will be null. Make sure the deliverable is generated by adding a [Wait for envelope](/docs/integrations/power-automate/actions/wait-envelope) action before this action. The ID of the envelope. Time at which the envelope was completed by all recipients, in ISO 8601 format. Whether the envelope is in `live` or `test` mode. Test mode envelopes are non-binding and not billed. Regulatory or compliance attestation. Use to classify envelopes and filter webhook notifications. Custom label given to the envelope for easier identification. Labels are for internal use and are not shown to recipients. The order in which recipients sign the envelope. It can be `parallel`, where all recipients can sign simultaneously, or `sequential`, where recipients sign one after another. The time zone to be used for timestamps in deliverables. The date and time format to be used in timestamps for deliverables. # Authentication Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/authentication Set up API key authentication to connect SignatureAPI with Power Automate ## Get your API Key SignatureAPI actions and triggers in Power Automate authenticate using an **API key**. If you haven’t already, [sign up for a free SignatureAPI account](https://accounts.signatureapi.com/sign-up). To get your API key: 1. Go to **Dashboard > Settings > API Key**. 2. Click to copy your **test API key**. ## Test vs Live Mode **Test API keys** let you create envelopes for testing your flows. These envelopes: * Don’t send real emails to recipients (but you can preview them in the Email section of your dashboard). * Are not legally binding. * Are free to use. When you're ready to send real, legally-binding envelopes, add a payment method and get a **live API key**. Envelopes created in live mode: * Send actual emails to recipients. * Are legally binding. * Are billed. ## Creating a Connection The first time you add a SignatureAPI trigger or action in Power Automate, you’ll be asked to create a connection. You can name the connection (for example, **SignatureAPI Test** or **SignatureAPI Live**), depending on which API key you're using. # Can I _______ ? Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/can_i Quick answers to common Power Automate questions about signers, templates, and signature positioning * Can I have multiple signers in my envelope? [Yes!](/docs/integrations/power-automate/actions/add-recipient) * Can I have the signers sign in a specific order? [Yes!](/docs/integrations/power-automate/envelopes/routing#sequential-routing) * Can I have multiple documents in my envelope? [Yes!](/docs/integrations/power-automate/actions/add-document) * Can I generate a document from a template and data? [Yes!](/docs/integrations/power-automate/documents/templates) * Can I place a signature using coordinates (for fixed-layout forms, for example)? [Yes!](/docs/integrations/power-automate/places/positioning#fixed-positions) * Can I place a signature using a placeholder within the document? [Yes!](/docs/integrations/power-automate/places/positioning#placeholders) * Can I ask for initials? [Yes!](/docs/integrations/power-automate/places/initials) * Can I ask my recipients for information (with input fields)? [Yes!](/docs/integrations/power-automate/places/text-input) * Can I get that recipient input into my flow? [Yes!](/docs/integrations/power-automate/envelopes/captures) * Can I change the language of the signing interface and emails? [Yes!](/docs/integrations/power-automate/envelopes/language) * Can I use a different time zone (for example America/New\_York) for timestamps? [Yes!](/docs/integrations/power-automate/envelopes/timezone) * Can I use a different date format (for example Month/Day/Year) in timestamps? [Yes!](/docs/integrations/power-automate/envelopes/timestamp-format) * Can I have the signing URL so I can send it myself to the recipients? [Yes!](/docs/integrations/power-automate/recipients/authentication/custom) * Can I start a flow when my envelope is completed? [Yes!](/docs/integrations/power-automate/triggers) * Can I retrieve the signed document? [Yes!](/docs/integrations/power-automate/guides/how-to/save-deliverables) * Can I trigger my flow only for certain envelopes [Yes!](/docs/integrations/power-automate/guides/how-to/filter-triggers) # The Audit Log Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/deliverables/audit-log Tamper-proof PDF containing signed documents and a cryptographically sealed event log The **Audit Log** is a type of [deliverable](/docs/integrations/power-automate/deliverables/deliverable), provided as a PDF document that includes the signed documents along with a log of the envelope events. The Audit Log is tamper-proof, secured with a cryptographic seal that can be used [to verify its authenticity](/docs/integrations/power-automate/deliverables/verification). Download an example of an audit log. Here is a screenshot of the log page of an Audit Log: # The deliverable Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/deliverables/deliverable The final PDF containing signed documents and audit log generated after envelope completion A deliverable is a PDF document that contains the signed documents of a completed document along with an audit log. The deliverable is generated after the envelope is completed, and is sent to all recipients via email. ## Relationships A deliverable belongs to an [envelope](/docs/integrations/power-automate/envelopes/envelope). # Verify a Deliverable Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/deliverables/verification Verify deliverable authenticity using Adobe Acrobat Reader's digital signature validation To verify that a deliverable was generated by SignatureAPI, open the PDF in **Adobe Acrobat Reader** (free) or **Adobe Acrobat** (paid). 1. **Check the signature status.**\ Look for a green check mark next to the signature icon. You should see the message:\ **"Signed and all signatures are valid."** Valid Signature Message in Adobe Acrobat 2. **Open the Signature Panel.**\ Review the signature details. All SignatureAPI deliverables are signed with a digital certificate issued to **Signature API, Inc.**\ To view the certificate's serial numbers and fingerprints, go to the [API verification guide](/docs/api/resources/deliverables/verification). # The document Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/documents/document PDF or DOCX files within an envelope for signing or informational purposes A **document** is a file within an envelope. It can be either a signable item, such as a contract, or for informational purposes only, like a cover letter. It can be either in PDF or docx format. Using [templates](/docs/integrations/power-automate/documents/templates), documents can be generated programmatically by combining a static template with dynamic data. ## Relationships A document belongs to an [envelope](/docs/integrations/power-automate/envelopes/envelope). ## Places [Places](/docs/integrations/power-automate/places/place) are specific areas in a document where recipients can perform actions, such as [signing](/docs/integrations/power-automate/places/signature) or entering data. They can also include information generated during the signing process, like [signing dates](/docs/integrations/power-automate/places/date). You can position places in the document either by using a [placeholder](/docs/integrations/power-automate/places/positioning#placeholders) or by setting them in a [fixed position](/docs/integrations/power-automate/places/positioning#fixed-positions). These places are specified in the `places` array within the Document object. Fixed positions are defined in the `fixed_positions` array. # File Sources in Power Automate Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/documents/sources A few Power Automate actions where you can get your documents from These are a few examples of actions you can use as source for your documents. In general, you can use any action or trigger that includes a binary format output. These outputs are usually called "File Content". ### Microsoft Sharepoint * [Get File Content](https://learn.microsoft.com/en-us/connectors/sharepointonline/#get-file-content) * [Get file content using path](https://learn.microsoft.com/en-us/connectors/sharepointonline/#get-file-content-using-path) * [Get attachment content](https://learn.microsoft.com/en-us/connectors/sharepointonline/#get-attachment-content) ### OneDrive for Business * [Get file content](https://learn.microsoft.com/en-us/connectors/onedriveforbusiness/#get-file-content) * [Get file content using path](https://learn.microsoft.com/en-us/connectors/onedriveforbusiness/#get-file-content-using-path) * [Convert file](https://learn.microsoft.com/en-us/connectors/onedriveforbusiness/#convert-file-\(preview\)): Use this to convert files into PDF. You can convert these file formats to PDF: Word, Excel, Powerpoint, HTML, and emails. * [Convert file using path](https://learn.microsoft.com/en-us/connectors/onedriveforbusiness/#convert-file-using-path-\(preview\)): Same as Convert File ### Dropbox * [Get file content](https://learn.microsoft.com/en-us/connectors/dropbox/#get-file-content) * [Get file content using path](https://learn.microsoft.com/en-us/connectors/dropbox/#get-file-content-using-path) ### Google Drive * [Get file content using id](https://learn.microsoft.com/en-us/connectors/googledrive/#get-file-content-using-id) * [Get file content using path](https://learn.microsoft.com/en-us/connectors/googledrive/#get-file-content-using-path) ### Box * [Get file content using id](https://learn.microsoft.com/en-us/connectors/box/#get-file-content-using-id) * [Get file content using path](https://learn.microsoft.com/en-us/connectors/box/#get-file-content-using-path) # Templates Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/documents/templates Generate documents programmatically using templates and dynamic data. When defining a document resource within an envelope, you have two options: using documents or templates. If you want to add signature places or dynamic data, such as the time a recipient signed, see [Places](/docs/integrations/power-automate/places/place). ## Documents vs Templates ### Documents If you have a PDF document ready you can simply provide the file in the **File Content** field of the [Add a document : PDF](/docs/integrations/power-automate/actions/add-document#param-file-content) action. This is a static document, meaning it will not change based on the data you provide. ### Templates SignatureAPI can generate documents programmatically from a static template combined with dynamic data. We accept templates in the DOCX format, which is widely supported by software such as Microsoft Word, Google Docs, and open-source productivity suites like [LibreOffice](https://www.libreoffice.org/). DOCX files created with software other than Microsoft Word (like Google Docs or LibreOffice) may not be processed correctly. If you get a [cannot-parse-document](/docs/v1/errors/cannot-parse-document) error, try opening the file in Microsoft Word and saving it again. If you don’t have Microsoft Word, contact support for help. Within the template, you can add [fields](#fields) and [conditionals](#conditionals). To add a document template to an envelope, use the [Add a template](/docs/integrations/power-automate/actions/add-template) action. This action allows you to upload a DOCX file and specify the data to be inserted into the template. #### Example Consider a template like this:
This Dummy Agreement is entered into by \{\{person.name}}, currently residing at \{\{person.address}}. The terms and conditions outlined in this agreement shall be governed by the laws of \{\{jurisdiction}}. \{\{if mediation}}
Any dispute shall be resolved by mediation, with each party bearing its own costs.
\{\{else}}
Any dispute shall be settled by arbitration, and the arbitrator's decision is final.
\{\{endif}}
When data is inserted: You get this document:
This Dummy Agreement is entered into by Sherlock Holmes, currently residing at 221b Baker Street, London. The terms and conditions outlined in this agreement shall be governed by the laws of The United Kingdom. Any dispute shall be settled by arbitration, and the arbitrator's decision is final.
## Fields Fields are markers within a template that indicate where specific information should be inserted. They are defined within your template with **double curly braces**, for example: `{{name}}`. For example, a template:
This Dummy Agreement is entered into by \{\{name}}.
With data: Will return the document:
This Dummy Agreement is entered into by Sherlock Holmes.
### Nested objects You can use nested objects in the data value. For example, a template:
This Dummy Agreement is entered into by \{\{person.name}}, currently residing at \{\{person.address.houseNumber}} \{\{person.address.streetName}}, \{\{person.address.city}}.
With a data value: Will return the document:
This Dummy Agreement is entered into by Sherlock Holmes, currently residing at 221b Baker Street, London.
## Conditionals Conditionals in templates allow for the inclusion or exclusion of content based on certain conditions. ### If You can use `{{if Condition}}` and `{{endif}}` to show or hide the content in between, depending on whether `Condition` is true or not. For example, a template:
Please read before proceeding. \{\{if showDisclaimer}}
Information provided is for educational purposes only and should not be considered as professional advice.
\{\{endif}} Use at your own discretion.
With the data value: Will return the document:
Please read before proceeding.
Information provided is for educational purposes only and should not be considered as professional advice.
Use at your own discretion.
But with the data value: Will return the document:
Please read before proceeding. Use at your own discretion.
### If-Else You can use `{{if Condition}}`, `{{else}}`, and `{{endif}}` to conditionally display content based on whether `Condition` is true or false." For example, a template:
\{\{if mediation}}
Any dispute shall be resolved by mediation, with each party bearing its own costs.
\{\{else}}
Any dispute shall be settled by arbitration, and the arbitrator’s decision is final.
\{\{endif}}
With data: Will return the document:
Any dispute shall be resolved by mediation, with each party bearing its own costs.
But with data: Will return the document:
Any dispute shall be settled by arbitration, and the arbitrator’s decision is final.
# Captures Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/envelopes/captures Access data entered by recipients during signing ceremonies in Power Automate flows Some types of [places](/docs/integrations/power-automate/places/place) allow [recipients](/docs/integrations/power-automate/recipients/recipient) to enter data during the ceremony, such as [text input places](/docs/integrations/power-automate/places/text-input). The content entered in these places is rendered on the documents once the recipients complete their participation. In some cases, you may also want to access this input data via the API. You can use **Captures** to store values entered by recipients during the ceremony. ## Defining Captures Places that allow arbitrary recipient input (like text input places) have a **Capture As** property. This property lets you define a key to identify the captured value within the envelope. **Capture As** keys must be unique within the envelope. For example, the following action adds a [Text Input Place](/docs/integrations/power-automate/places/text-input) that asks a recipient to enter an 8-digit reference number during the signing ceremony: When the customer (the Recipient) completes the ceremony, her reference number will be captured using the key `reference`. You can retrieve this captured value using the [Get captured value](/docs/integrations/power-automate/actions/get-capture) action: # The envelope Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/envelopes/envelope Container holding documents and recipients that manages the signing workflow An envelope is a container that holds [documents](/docs/integrations/power-automate/documents/document) to be sent to [recipients](/docs/integrations/power-automate/recipients/recipient). It defines and manages the signing process for those documents. When an envelope is [completed](#lifecycle), a [deliverable](/docs/integrations/power-automate/deliverables/deliverable) is generated and sent to the recipients. ## Relationships An envelope: * Has one or more [recipients](/docs/integrations/power-automate/recipients/recipient) * Has one or more [documents](/docs/integrations/power-automate/documents/document) * Has zero or one [deliverables](/docs/integrations/power-automate/deliverables/deliverable) ## Lifecycle The envelope's `status` indicates its current stage, tracking its progress through the signing process. Possible envelope status are: | | | | ------------- | ---------------------------------------------------------------------------------------------------------------- | | `draft` | The envelope is under construction. | | `processing` | The envelope is being prepared and has not yet been sent. | | `in_progress` | The envelope has been sent to recipients and is waiting for all participants to complete it (for example, sign). | | `completed` | All recipients have completed the envelope. | | `failed` | An internal error occurred. | | `canceled` | The signing process was intentionally stopped before completion. | # Language Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/envelopes/language Set the language for signing interfaces and recipient emails in Power Automate flows You can customize the language displayed to recipients in both the signing interface and emails to make them more familiar to your customers. ## Available Languages SignatureAPI currently supports these languages: | **Language** | **Code** | | -------------------- | -------- | | English | `en` | | Chinese (Simplified) | `zh` | | French | `fr` | | German | `de` | | Italian | `it` | | Portuguese (Brazil) | `pt` | | Spanish | `es` | | Hungarian | `hu` | More languages are coming soon! To ask about the timeline for a specific language, [contact support](https://signatureapi.com/support). ## Default Language Set your account’s default language in the Settings section of the dashboard. If needed, you can override this default for individual envelopes by specifying the `language` parameter when creating the envelope. ## Envelope Language To use a different language for a specific envelope, set the `language` parameter when creating the envelope: ## How does it looks ### Emails The language you choose appears in signing requests and when sending completed documents. ![](https://whimuc.com/QQDubRnfFPHF1uvj5mB5n8/FAeEybhARmeXhs.png) ### Ceremony Interface Recipients see your chosen language in buttons, messages, and click-through agreements during signing. ![](https://whimuc.com/QQDubRnfFPHF1uvj5mB5n8/BpijVijqeNz4fg.png) ### Deliverables The audit log attached to signed documents is shown in your selected language. ![](https://whimuc.com/QQDubRnfFPHF1uvj5mB5n8/BWR8ZFpCd1thXM.png) # Recipient Routing Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/envelopes/routing Control signing order with sequential or parallel recipient routing in Power Automate When sending an envelope for signatures, you can control how it's sent to recipients using the routing property in the [Envelope](/docs/integrations/power-automate/envelopes/envelope). There are two options: **Sequential** and **Parallel**. By default, SignatureAPI uses sequential routing. ## Sequential Routing With **Sequential Routing**, the envelope is sent to one recipient at a time, in the order you specify in the envelope's recipient array. The next recipient only receives the document after the previous one has signed. **Key Points**: * Recipients sign in the order set in the envelope's `recipient` array. * The envelope is sent to the next recipient only after the previous one signs. * Ideal for workflows where the order of signatures matters. * Next recipients can see the signatures and data introduced by the previous recipients. * Recipients that depends on the completion of another one will have the status awaiting. ## Parallel Routing With **Parallel Routing**, the envelope is sent to all recipients at the same time. Each recipient can sign the document whenever they want, and there is no required signing order. **Key Points**: * All recipients receive the envelope simultaneously. * They can sign in any order. * Best for cases where the signing order doesn't matter. ## Setting the Envelope's Routing By default, envelopes are sent in **Sequential**. If you don't need a specific signing order, set routing to **Parallel**. # Timestamp Format Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/envelopes/timestamp-format Customize date and time format displayed in deliverables for Power Automate flows In addition to time zones, you can customize the timestamps in the deliverables sent to your customers. ### Default Timestamp Format To set a new default timestamp format for your account: 1. Go to [dashboard settings](https://dashboard.signatureapi.com/settings/general). 2. Navigate to the **Timestamp Format** section. ![](https://whimuc.com/QQDubRnfFPHF1uvj5mB5n8/ApMPHKzHXVMfoV.png) ### Envelope Timestamp Format To set a specific timestamp format for an individual envelope, use the `timestamp_format` parameter when creating the envelope: ## Building a Timestamp Format Use these tokens to build timestamp formats: | **Token** | **Description** | | --------- | -------------------- | | YYYY | Year | | MM | Month | | DD | Day | | HH | Hour (24-hour clock) | | hh | Hour (12-hour clock) | | mm | Minutes | | ss | Seconds | You can use these separators: * **Date separators**: `/` (slash), `-` (dash), `.` (period), `(space)` * **Time separators**: `:` (colon), `.` (period) For example, to build the commonly used US date format, you would use the following tokens and separators: `MM/DD/YYYY hh:mm:ss` This will appear in the audit logs as `12/31/2025 11:59:59 PM`. ## Examples of Timestamp Formats Here are common timestamp formats used in different regions: | **Timestamp format** | **Example** | **Common Usage** | | --------------------- | ---------------------- | --------------------------------------------------- | | `MM/DD/YYYY hh:mm:ss` | 12/31/2025 11:59:59 PM | Primarily in the United States | | `DD/MM/YYYY HH:mm:ss` | 31/12/2025 23:59:59 | Europe, Australia, parts of Asia and Africa | | `YYYY-MM-DD HH:mm:ss` | 2025-12-31 23:59:59 | ISO 8601 international standard | | `DD/MM/YYYY hh:mm:ss` | 31/12/2025 11:59:59 PM | Informal usage globally | | `DD.MM.YYYY HH:mm.ss` | 31.12.2025 23:59.59 | Commonly in Germanic and Eastern European countries | ## How Does It Look Dates appear in the audit log in the specified format: ![](https://whimuc.com/QQDubRnfFPHF1uvj5mB5n8/6X5k2BaHhXA6j3.png) # Time Zone Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/envelopes/timezone Configure time zones for deliverable timestamps in Power Automate flows Time zones ensure that the way time is displayed in your deliverables is relevant for you and your customers. ## Default Time Zone Your account's default time zone can be set in the Settings section of the dashboard. ## Envelope Time Zone You can override the default time zone for individual envelopes by setting the timezone parameter when creating the envelope. ## Common Time Zone Identifiers SignatureAPI uses identifiers from the [TZ Database](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones). Here are examples of some identifiers: | **Zone Name Identifier** | **Zone Description** | | ------------------------ | --------------------------- | | US/Pacific | West coast of North America | | US/Eastern | East coast of North America | | Europe/London | United Kingdom | | Asia/Singapore | Singapore | We recommend using zone name identifiers because they automatically handle daylight saving changes. Alternatively, you can use generic offsets such as `Etc/GMT+2`. # Topics and Filters Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/envelopes/topics Topics help you organize envelopes and filter triggers. Topics are tags you add to envelopes. Each envelope can have up to 10 topics. Use topics to filter triggers. Filtering ensures workflows run only when relevant envelopes change. ## Example: Using Topics in a Company Imagine a company has two departments: **Finance** and **Sales**. Both departments use SignatureAPI but have different Power Automate flows. ### Without Topics If you do not use topics, both finance and sales flows activate every time any envelope changes. This causes unnecessary notifications and complexity, as each department sees irrelevant envelopes. ### With Topics Topics simplify workflows by categorizing envelopes. Assign topics to envelopes based on departments or workflows. Then, trigger flows only for the topics you choose. In our example: 1. **Assign Topics:** * Finance envelopes get the topic `finance`. * Sales envelopes get the topic `sales`. * Some envelopes may have both topics (`finance` and `sales`). 2. **Configure Flows:** * Set each flow to trigger only on its specific topic. * For example, set the finance flow to trigger on the topic `finance`. Then, only finance envelopes trigger this flow. * If you do not set a topic filter, the flow triggers for all envelopes. # Getting Started Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/getting-started Start using the SignatureAPI connector in Power Automate The SignatureAPI connector lets you add electronic signatures to your Power Automate flows. ## Get a Test API Key To use SignatureAPI in Power Automate, you need an API key. You can start with a free test API key to try out the platform. Here’s how: [Sign up](https://accounts.signatureapi.com/sign-up) for a free SignatureAPI account. Go to the [API Key section](https://dashboard.signatureapi.com/settings/api-keys) in your SignatureAPI settings to get your test key. Test API keys let you create test envelopes. These are useful when building and testing your flows. Test envelopes: * Don’t send emails to recipients, but you can see them in the Email section of your dashboard. * Are not legally binding. * Are free to use. ## Create a Connection Use your test API key to create a connection to SignatureAPI in Power Automate: In Power Automate, open an existing flow or create a new one. Add the [Create Envelope](/docs/integrations/power-automate/actions/create-envelope) action from SignatureAPI. Enter a name for your connection (for example, `SignatureAPI Test`) and paste your test API key. Learn more about [API keys and how to create them](/docs/api/authentication). ## Your First SignatureAPI Flow Follow our [Quickstart](/docs/integrations/power-automate/guides/quickstart) to create an envelope and send it with SignatureAPI. ## Switch to Live Mode When you're ready to send legally binding envelopes, add a payment method and get a live API key. Live envelopes: * Send emails to recipients. You can also view these emails in your dashboard. * Are legally binding. * Are billed. We recommend creating a new connection with your live API key. You can name it something like `SignatureAPI Live`. # Sending Contracts via SMS with Twilio, SharePoint List, SignatureAPI, and Power Automate Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/ceremony-custom-twilio Send signing links via SMS using Twilio when new SharePoint list items are created ## Overview This tutorial shows you how to automate employment contract signing by sending contracts via SMS with **Twilio** when a new **SharePoint List** item is created. By integrating **SharePoint List** (for storing employee details), the **SignatureAPI connector** (for electronic signatures), **Twilio** (for sending SMS with the signing link), **Outlook** (for notifying HR when the contract is signed), and **Power Automate** (for orchestrating the workflow), you can eliminate manual errors and reduce delays in onboarding new employees. ### What You'll Learn * How to trigger a flow when a new SharePoint List item is created. * How to retrieve and pre-fill a DOCX contract template with employee details. * How to create and send a signature envelope via SMS using SignatureAPI and Twilio. * How to monitor the signing process and retrieve the signed document. * How to save the signed contract and notify HR automatically. ### The Problem HR departments often struggle with manually handling contracts, causing delays in onboarding. Common issues include: * **Slow processing:** Manual tasks create bottlenecks. * **Errors:** Mistakes from manual data entry. * **Tracking difficulty:** Challenges in monitoring signing status. ### How Automation Helps Automation simplifies this process by: * Automatically sending contracts to employees via SMS. * Using templates pre-filled with employee details. * Tracking signature status and storing documents automatically. * Informing HR instantly once contracts are signed. ## Requirements Before starting, make sure you have: * **Power Automate** for building workflows. * **SignatureAPI account** for electronic signatures. * **Twilio account** for sending SMS (make sure you have a phone number that can send SMS). * **SharePoint List** for storing employee details. * **Outlook** for sending notifications (other email providers also work). ## Flow Overview The automation process follows these steps: 1. **Trigger:** A new SharePoint List item starts the flow. 2. **Data Retrieval:** Get employee details and fetch the contract template from SharePoint. 3. **Signature Process:** Create an envelope via SignatureAPI, add recipient details, and attach the contract template. 4. **SMS Delivery:** Create a ceremony when the recipient is released, then send an SMS with the signing link via Twilio. 5. **Monitoring:** Wait for the contract to be signed. 6. **Storage and Notification:** Save the signed document in SharePoint and notify HR via email. This use case has three flows: 1. SharePoint List flow Sharepoint List flow 2. Send SMS flow Send SMS flow 3. Monitoring flow Monitoring flow ## Step-by-Step Tutorial Follow these steps to automate your employment contract process using SharePoint List, SignatureAPI, Twilio, and Power Automate. ### Step 1: Prepare the Contract Template First, create or update your employment contract template by adding placeholders for dynamic fields (employee details) and defining where the employee will sign. **To prepare your template:** 1. Open your existing employment contract document (DOCX format) in Microsoft Word. 2. Identify each place where employee details should be dynamically inserted (e.g., first name, last name, email). 3. Insert placeholders using **double curly brackets** around descriptive keys. Examples: * Employee first name: `{{employee.first_name}}` * Employee last name: `{{employee.last_name}}` * Employee email: `{{employee.email}}` 4. Define the location for the signature clearly by inserting a signature placeholder using **double square brackets**, e.g.: `[[employee_signature]]` **Example placeholder usage in your document:** > *Dear `{{employee.first_name}}` `{{employee.last_name}}`,* > *Please review and sign your employment contract below:* > `[[employee_signature]]` 5. Save your template. Ensure placeholder keys match exactly with what you will use later in Power Automate. Keep your template simple and clear to avoid confusion during dynamic insertion. Word Template Example ### Step 2: Create the SharePoint List Create a SharePoint List to store employee details. 1. Visit [Microsoft Lists](https://www.microsoft.com/en-us/microsoft-365/microsoft-lists) and sign in. 2. Click **New List**, then click **Blank List**. New List 3. Rename the list and save it to the SharePoint Site. Rename List 4. Add the following columns: * **First Name** (Text) * **Last Name** (Text) * **Email Address** (Text) * **Phone** (Text) * **RecipientId** (Text) Add Columns Add Columns 5. Save and publish the list. Save List ### Step 3: Set Up the Power Automate Flow Now, create the automated workflow in Power Automate. This flow triggers whenever a new item is added to the SharePoint List. #### 3.1 Configure the Trigger 1. Go to **Power Automate** and select **Automated Cloud Flow**. 2. Name your flow, select **When an item is created** from the SharePoint connector, then click **Create**. Trigger 3. Select the Site Address and the list you created earlier. Select List #### 3.2 Get File Content 1. Add the **Get file content using path** action from the SharePoint connector. 2. Select the document from SharePoint Documents. Get file content ### Step 4: Set Up the Signature Process In this step, you will configure SignatureAPI to create, send, and track the signature process. #### 4.1 Create a SignatureAPI Envelope Begin by creating an envelope to hold your contract and signature process. 1. Add the **Create an Envelope** action (SignatureAPI connector). 2. If prompted, authenticate your connection using your SignatureAPI key from the [SignatureAPI Dashboard](https://dashboard.signatureapi.com/settings/api-keys). 3. Set an **Envelope Title** (e.g., employee first name) and a message using dynamic content. 4. From the advanced options, set the **Envelope Topics** to `twilio_agreement`. This allows you to filter the other flows by this topic. You can use any string you want. Create envelope #### 4.2 Add the Recipient Next, specify who will receive and sign the contract. 1. Add the **Add Recipient** action from the SignatureAPI connector. 2. Map **Recipient Name** and **Recipient Email** using dynamic content from the SharePoint List item. 3. Set the **Recipient Key** (e.g., `employee`), matching your DOCX placeholders. 4. From the advanced options, set **Recipient Ceremony Creation** to `manual`. This allows you to create a ceremony later in the flow. Add recipient #### 4.3 Update the SharePoint List Item with the Recipient ID 1. Add the **Update item** action from the SharePoint connector. 2. Select the Site Address and the list you created earlier. 3. Select the Item ID from the previous step with dynamic content. 4. Set the **RecipientID** to the **RecipientID** from the **Add Recipient** action. Update item #### 4.4 Attach the DOCX Contract Template Now, attach your contract template to the envelope and populate it with employee details. 1. Add the **Add a Template (DOCX)** action. 2. Select **File Content** from the **Get file content using path** action. 3. Select the Envelope ID from the **Create an Envelope** action. 4. Set the **Document Title** (e.g., "Employment Contract"). 5. Ensure your DOCX template uses placeholders (`{{employee.first_name}}`, etc.) and map each field to the corresponding dynamic content. Add template #### 4.5 Define Signature Placement Specify where the employee should sign on the document. 1. Add the **Add a Place (Signature)** action. 2. Set the **Document ID** using dynamic content. 3. Use the placeholder (e.g., `[[employee_signature]]`) from your DOCX template. 4. Set the **Recipient Key** using dynamic content. Add signature #### 4.6 Start the Signing Process Trigger the sending of your envelope to the employee for signing. 1. Add the **Start Envelope** action from the SignatureAPI connector. 2. Select the appropriate **Envelope ID** using dynamic content. Start envelope ### Step 5: Create the Ceremony and Send SMS Create a second Power Automate flow that triggers whenever a recipient is released from the SignatureAPI connector. #### 5.1 Configure the Trigger 1. Go to **Power Automate** and select **Automated Cloud Flow**. 2. Select **When a recipient is released** from the SignatureAPI connector. Trigger #### 5.2 Filter by Envelope Topic 1. In the trigger, set **Topics** to `twilio_agreement`. This ensures the flow only runs for envelopes created with this topic. Filter array #### 5.3 Get SharePoint List Items by Recipient ID 1. Add the **Get Items** action from the SharePoint connector. 2. Select the Site Address and the list you created earlier. 3. From the advanced options, set the **Filter Query** to `RecipientId eq 'Recipient ID'` (where `Recipient ID` is the value from the trigger's dynamic content). Also set the **Top Count** to `1`. Get items #### 5.4 Get Item by ID 1. Add the **Get Item** action from the SharePoint connector. 2. Select the Site Address and the list you created earlier. 3. In the **Id** field, insert an expression to get the Item ID from the previous step. Use this expression: ``` first(body('Get_items')?['value'])?['ID'] ``` Get item #### 5.5 Create Ceremony 1. Add the **Create a ceremony (Custom Authentication)** action from the SignatureAPI connector. 2. In the **Authentication Provider** field, set the name of the SharePoint list you are using (e.g., "Super App Tutorial"). 3. In the **Authentication Data**, add the following fields: * **Authentication Method:** SMS * **Phone Number:** The recipient's phone number (selected from the SharePoint List item via dynamic content) 4. Set the **Recipient ID** from the dynamic content. Create ceremony #### 5.6 Send SMS 1. Add the **Send Text Message (SMS)** action from the Twilio connector. 2. Set **From** to your Twilio phone number. 3. Set **To** to the recipient's phone number. 4. Set **Message** to include the ceremony URL from the dynamic content. Send SMS ### Step 6: Monitor and Finalize the Contract Create a third Power Automate flow that triggers whenever a deliverable is generated from the SignatureAPI connector. This flow retrieves the signed contract, saves it to SharePoint, and notifies HR. #### 6.1 Configure the Trigger 1. Go to **Power Automate** and select **Automated Cloud Flow**. 2. Select **When a deliverable is generated** from the SignatureAPI connector. Trigger #### 6.2 Filter by Envelope Topic 1. In the trigger, set **Topics** to `twilio_agreement`. This ensures the flow only runs for envelopes created with this topic. Filter array #### 6.3 Retrieve the Signed Contract Once the contract is signed, automatically retrieve the completed document. 1. Add the **Get a Deliverable** action from the SignatureAPI connector. 2. Select the correct **Deliverable ID** using dynamic content. Get deliverable #### 6.4 Save the Signed Contract to SharePoint Save the signed document for record-keeping. 1. Add the **Create File** action (SharePoint connector). 2. Select the **Site Address** and **Folder Path**. 3. Set the **File Name** (ending in `.pdf`). 4. Map **File Content** from the deliverable. Save file #### 6.5 Notify HR via Email Automatically inform HR that the contract has been signed and saved. 1. Add the **Send an Email** action (Outlook connector). 2. Configure the email recipient (HR), subject, and message. 3. Attach the signed contract file from dynamic content. Use the **File Content** from the **Get a Deliverable** action and set the filename (ending in `.pdf`). Send email ### Step 7: Test Your Automation Finally, test the entire process end-to-end. 1. Save all three Power Automate flows. 2. Create a new item in the SharePoint List. 3. Verify the following: * The ceremony is created successfully. * The SMS is sent to the employee. * The employee receives the SMS and signs the contract. * The signed contract saves successfully in SharePoint. * HR receives an email notification with the signed contract attached. *Use the following checklist:* * [ ] Ceremony is created successfully. * [ ] SMS is sent to the employee. * [ ] Employee receives the SMS and signs the contract. * [ ] Signed document stored correctly in SharePoint. * [ ] HR receives email notification with attachment. ## Troubleshooting & FAQ ### Common Issues * **API Key Errors:** Ensure your SignatureAPI key is correct and authenticated. * **Dynamic Content Mapping:** Double-check that placeholder names in your DOCX file match exactly with the dynamic content mappings in Power Automate. * **File Access Issues:** Verify permissions and file paths in SharePoint. * **SMS Not Received:** Confirm your Twilio phone number is SMS-enabled and the recipient's phone number is in the correct format. * **Ceremony Not Created:** Verify that the **Recipient Ceremony Creation** is set to `manual` in the **Add Recipient** action, and that the recipient ID is correctly stored in the SharePoint List. ## Additional Resources * [SignatureAPI Documentation](https://signatureapi.com/docs) * [Microsoft SharePoint List Documentation](https://www.microsoft.com/en-us/microsoft-365/microsoft-lists) * [Twilio Documentation](https://www.twilio.com/docs) * [Power Automate Community](https://powerusers.microsoft.com/t5/Microsoft-Power-Automate/ct-p/MPACommunity) ## Conclusion By completing this tutorial, you have successfully automated the process of sending contracts for signature via SMS using Twilio, SignatureAPI, and Power Automate. This workflow ensures employees receive signing links directly on their phones, speeding up the contract process. **Happy Automating!** # Embed a Signature Ceremony in Power Pages with SignatureAPI Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/ceremony-embedded-power-pages Learn how to embed a SignatureAPI signature ceremony directly into a Microsoft Power Pages form using Power Automate. ## Overview This tutorial walks you through embedding a SignatureAPI signature ceremony directly into a Microsoft Power Pages site. By combining Power Pages (for the customer-facing form), OneDrive (for template storage), and the SignatureAPI connector (for electronic signatures), you can let customers fill out a form and sign a document without ever leaving your website. ### What You'll Learn * How to trigger a Power Automate flow from a Power Pages form submission. * How to retrieve and pre-fill a DOCX contract template stored in OneDrive. * How to create and send a signature envelope using SignatureAPI. * How to configure a ceremony with custom authentication for embedding. * How to edit the Power Pages source code to invoke the flow on form submission. * How to embed the signature ceremony iframe in your Power Pages site. ### The Problem Many companies need to collect information from customers and have them sign documents as part of the same workflow. Without automation, this process introduces several pain points: * **Manual signature handling** -- customers must sign documents outside of the web experience, adding friction and delays. * **Disconnected user experience** -- the signature step happens on a separate page or platform, breaking the flow for the customer. * **No dynamic document generation** -- staff must manually insert customer details into contracts before sending them for signature. ### How Automation Helps * Automatically generates a personalized contract from a template using customer-submitted form data. * Creates a signature envelope and recipient in SignatureAPI without manual intervention. * Returns an embeddable ceremony URL so the customer can sign directly on your Power Pages site. * Eliminates context-switching for the customer by keeping the entire process on a single page. ## Requirements Before starting, make sure you have: * **Power Automate** -- to build the automated workflow. * **SignatureAPI account** -- for electronic signatures. You can obtain an API key from the [SignatureAPI Dashboard](https://dashboard.signatureapi.com/settings/api-keys). * **Power Pages** -- for hosting the customer-facing form and embedded ceremony. * **OneDrive / SharePoint** -- for storing your DOCX contract template. ## Flow Overview The automation process follows these steps: 1. **Trigger:** A Power Pages form submission starts the flow. 2. **Data Retrieval:** Collect customer details from the form inputs and fetch the DOCX template from OneDrive. 3. **Signature Process:** Create an envelope via SignatureAPI, add the recipient, attach the DOCX template, define the signature placement, and start the envelope. 4. **Ceremony Creation:** Create a ceremony with custom authentication and return the embeddable URL to Power Pages. Here is what your final Power Automate flow will look like. Note that the flow is created from Power Pages, but you can also view it from the Power Automate dashboard. Complete Flow ## Step-by-Step Tutorial Follow these steps to automate your signature process using Power Pages, SignatureAPI, and Power Automate. ### Step 1: Prepare the Agreement Template Create or update your agreement template by adding placeholders for dynamic fields and defining where the customer will sign. **To prepare your template:** 1. Open your existing customer agreement document (DOCX format) in Microsoft Word. 2. Identify each place where customer details should be dynamically inserted (for example, name and email). 3. Insert placeholders using **double curly brackets** around descriptive keys. Examples: * Customer name: `{{customer.name}}` * Customer email: `{{customer.email}}` 4. Define the signature location by inserting a signature placeholder using **double square brackets**: `[[customer_signature]]` **Example placeholder usage in your document:** > *Dear `{{customer.name}}`,* > *Please review and sign your agreement below:* > `[[customer_signature]]` 5. Save your template and upload it to **Documents** in your **SharePoint Site**. **Important:** Ensure placeholder keys match exactly with what you configure later in Power Automate. Keep your template simple and clear to avoid confusion during dynamic insertion. Word Template Example ### Step 2: Create the Power Pages Site 1. Visit [Power Pages](https://make.powerpages.microsoft.com) and sign in. 2. From the left-hand menu bar, in the **Home** section, click **Start from blank**. Start from blank 3. Name the site (for example, "Customer Agreement Form"), set the web address (for example, "customer-agreement-form"), and click **Done**. Name and address ### Step 3: Set Up the Power Automate Flow Create the automated workflow in Power Automate directly from Power Pages. #### 3.1 Set the Flow Trigger 1. From the left-hand menu bar, click **Set up** and select **Cloud Flows**. 2. Click **Create new flow**. Create new flow 3. Rename the flow (for example, "Customer Agreement Flow"), select the **When Power Pages calls a flow** trigger, and give it a name (for example, "Customer Agreement"). Select trigger #### 3.2 Add Inputs 1. Click on the trigger and select **Add an input**. Choose the **Text** type and enter `customerName` as the input name. 2. Repeat this step to add a second text input named `customerEmail`. Add Input 1 Add Input 2 ### Step 4: Retrieve the Contract Template from OneDrive Fetch your customer agreement template stored in OneDrive. 1. Add the **Get File Content using Path** action from the OneDrive connector. 2. Select the DOCX template stored in your OneDrive. Get File Content ### Step 5: Set Up the Signature Process Configure SignatureAPI to create, send, and track the signature process. #### 5.1 Create a SignatureAPI Envelope 1. Add the **Create an Envelope** action from the SignatureAPI connector. 2. If prompted, authenticate your connection using your SignatureAPI key from the [SignatureAPI Dashboard](https://dashboard.signatureapi.com/settings/api-keys). Create Connection 3. Set an **Envelope Title** (for example, the customer name) and an email message using dynamic content. Create Envelope #### 5.2 Add the Recipient (Signer) Specify who will receive and sign the contract, with manual ceremony creation. 1. Add the **Add Recipient - Signer** action. 2. Set the **Envelope ID** from the dynamic content. 3. Map the **Recipient Name** and **Recipient Email** using form details from dynamic content. 4. Set the **Recipient Key** (for example, `customer`) to match your DOCX placeholders. 5. In the **advanced options**, set **Recipient Ceremony Creation** to `manual`. Add Recipient #### 5.3 Attach the DOCX Contract Template Attach your contract template to the envelope and populate it with customer details. 1. Add the **Add a Template - DOCX** action. 2. Set the **Envelope ID** from the dynamic content. 3. Select the **File Content** from the SharePoint action. 4. Set the **Document Title** (for example, "Customer Agreement"). 5. Map each placeholder field (`{{customer.name}}`, `{{customer.email}}`) to the corresponding dynamic content from the flow inputs. Add Template #### 5.4 Define Signature Placement Specify where the customer should sign on the document. 1. Add the **Add a Place - Signature** action. 2. Set the **Document ID** using the dynamic content. 3. Enter the placeholder from your DOCX template (for example, `[[customer_signature]]`). 4. Set the **Recipient Key** using the dynamic content. Add Place Signature #### 5.5 Start the Signing Process Trigger the sending of your envelope to the customer for signing. 1. Add the **Start Envelope** action. 2. Set the **Envelope ID** using the dynamic content. Start Envelope #### 5.6 Create the Ceremony Create a ceremony with custom authentication. This returns a URL that you will use to embed the signing experience in Power Pages. 1. Add the **Create Ceremony - Custom authentication** action from the SignatureAPI connector. 2. Set the **Recipient ID** using dynamic content. 3. Set the **Authentication Provider** to the provider you want to use. This value appears in the Audit Log of the deliverable as the security provider for the ceremony. 4. Set the **Authentication Data** to the verification data for the user and provider. This also appears in the Audit Log. 5. In the **advanced options**, under the **Extra Properties** section, add the following JSON: ```json theme={null} {"embeddable_in":["*"]} ``` This allows the ceremony to be embedded in any Power Pages site. Create Ceremony #### 5.7 Return the Ceremony URL to Power Pages 1. Add an output of type **Text**. 2. Set the **Name** to the variable name you want to return (for example, `url`). 3. Set the **Value** to the ceremony URL from the **Create Ceremony - Custom authentication** action using dynamic content. Return Ceremony ### Step 6: Save the Flow and Add It to Power Pages 1. Save the flow and copy the flow URL. 2. Set the roles and permissions for the flow. In this example, allow all roles to access the flow. Add Flow ### Step 7: Add the Form and Embed the Ceremony in Power Pages To invoke the Power Automate flow from a form submission, you need to add custom HTML and JavaScript to your Power Pages site using the Visual Studio Code editor. #### 7.1 Open Power Pages in the VS Code Editor 1. From the left-hand menu bar, click **Pages** to view all pages on the site. Show Pages 2. Click **Edit code**. This opens the VS Code editor with the Power Pages source code, starting on the home page. VS Code Opened #### 7.2 Add the Form and Ceremony Embed Code In the VS Code editor, open the `Home.html` file and add the following code. This creates a form that collects the customer's name and email, calls the Power Automate flow on submission, and displays the returned ceremony in an iframe. The code has three main sections: * **Form HTML** -- renders input fields for the customer's name and email, along with a submit button. * **Iframe container** -- a hidden iframe that becomes visible once the ceremony URL is returned. * **JavaScript** -- handles form submission, sends the data to the Power Automate flow, and loads the ceremony URL into the iframe. ```html theme={null}

Customer Agreement Form

Please fill out the form below. We'll use this information to generate or request a customer agreement.

``` 1. Copy and paste the code into the VS Code editor. 2. Replace the `_url` value (`"REPLACE_WITH_YOUR_FLOW_URL"`) with the actual flow URL you copied in Step 6. Edit URL in VS Code **Important:** The `data` object keys in the JavaScript must match the input names you defined in Step 3.2. If you rename or add inputs in the flow trigger, you must update the corresponding keys in the script. ```javascript theme={null} var data = {}; data["customerName"] = name; data["customerEmail"] = email; ``` 3. Save the file and refresh the Power Pages preview. The form collects the customer's details and, on submission, triggers the Power Automate flow and embeds the ceremony directly in the page. You can customize the styles and layout to match your site's design. VS Code with form ### Step 8: Test Your Automation Test the entire process end-to-end. 1. Go back to Power Pages. You should see the form on the home page. Click the **Preview** button and select the **Desktop** option. Click Preview 2. Fill out the form with a test name and email, then click **Send Request**. After a few seconds, the ceremony should appear embedded in the page. Preview Form Preview Embedded 3. Verify the following: * [ ] The ceremony is embedded and visible on the page. * [ ] The ceremony loads correctly and allows the signer to complete the signature. * [ ] The signed document appears in your SignatureAPI dashboard after completion. ## Troubleshooting & FAQ ### Common Issues: * **API Key Errors:** Ensure your SignatureAPI key is correct and that the connection is authenticated in Power Automate. * **Dynamic Content Mapping:** Double-check that placeholder names in your DOCX file match exactly with the dynamic content mappings in the flow. * **File Access Issues:** Verify that permissions and file paths in OneDrive or SharePoint are configured correctly and accessible by the flow. ### Frequently Asked Questions: * *What if the ceremony does not appear after form submission?* Open your browser's developer console to check for errors. Also verify that the flow ran successfully in Power Automate and that the ceremony URL was returned correctly. * *Can I adapt this for other document types or workflows?* Yes. You can modify the DOCX template, add additional form fields, or change the flow logic to support different document-signing scenarios. * *How do I restrict which roles can trigger the flow?* In the Power Pages flow settings (Step 6), configure the role permissions to allow only specific roles instead of granting access to all roles. ## Best Practices & Security * Always store API keys securely and avoid hardcoding them in client-side code. The flow URL should be the only value placed in the page script. * Regularly monitor flow runs in Power Automate to catch and resolve errors early. * Document any changes to your flow or template so your team can maintain the integration over time. ## Additional Resources * [SignatureAPI Documentation](https://signatureapi.com/docs) * [Power Pages Documentation](https://learn.microsoft.com/en-us/power-pages/) * [Power Automate Community](https://powerusers.microsoft.com/t5/Microsoft-Power-Automate/ct-p/MPACommunity) ## Conclusion You have successfully embedded a SignatureAPI signature ceremony in a Power Pages site using Power Automate. Your customers can now fill out a form and sign documents without leaving your website. **Happy Automating!** # Automating Employment Contracts and Storing Data in Microsoft Dataverse with Microsoft Forms, SignatureAPI, and Microsoft Power Automate Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/envelope-add-row-to-dataverse Automate employment contract signing with form data capture and store employee details in Microsoft Dataverse using SignatureAPI and Power Automate ## Overview This tutorial demonstrates how to streamline the employment contract process by automatically sending, signing, and storing contracts. By integrating **Microsoft Forms** (for data collection), **OneDrive** (for storing contract PDF templates), the **SignatureAPI connector** (for electronic signatures with form inputs), and **Microsoft Dataverse** (for storing employee details from the form and signature completion), you can eliminate manual errors and delays in onboarding new employees. ### What You'll Learn * How to trigger a flow with a new Microsoft Forms response. * Retrieving and pre-filling a DOCX contract template from OneDrive. * Creating and sending a signature envelope using SignatureAPI for two recipients. * Capturing data from text input fields in the signature process. * Monitoring the signing process and retrieving the signed document. * Saving the signed contract, adding a row to a Dataverse table, and automatically notifying HR. ### The Problem HR departments often struggle with manually handling contracts, causing delays in onboarding. Common issues include: * **Slow processing** - manual tasks create delays. * **Errors** - mistakes from manual data entry. * **Tracking difficulty** - challenges in monitoring signing status. ### How Automation Helps Automation simplifies this process by: * Automatically sending contracts upon form submission. * Using templates pre-filled with employee details. * Using the SignatureAPI form to capture data from the signature process and then add a row to a Dataverse table. * Tracking signature status and storing documents automatically. * Informing HR instantly once contracts are signed. ## Requirements Before starting, make sure you have: * **Power Automate** - To build workflows. * **SignatureAPI account** - For electronic signatures with form inputs. * **Microsoft Forms** - For collecting employee information. * **OneDrive** - For storing your DOCX templates. * **Microsoft Dataverse** - For storing employee details from the form and signature completion. * **Outlook** - For sending notifications (other email providers also work). ## Flow Overview The automation process follows these steps: 1. **Trigger:** Microsoft Forms submission starts the flow. 2. **Data Retrieval:** Get employee details and fetch the contract template from OneDrive. 3. **Signature Process:** Create an envelope via SignatureAPI, add recipient details, and attach the DOCX. 4. **Monitoring:** Wait for the contract to be signed. 5. **Storage & Notification:** Save the signed document in OneDrive, add a row to a Dataverse table, and notify HR via email. Here's what your final Power Automate flow will look like: Flow ## Step-by-Step Tutorial Follow these steps to automate your employment contract process using Microsoft Forms, Microsoft Dataverse, SignatureAPI, and Power Automate: ### Step 1: Prepare the Contract Template First, create or update your employment contract template by adding placeholders for dynamic fields (employee details), defining the employer and employee signature fields, and adding a place for the salary amount that the employer will fill during the signature process. **To prepare your template:** 1. Open your existing employment contract document (DOCX format) in Microsoft Word. 2. Identify each place where employee details should be dynamically inserted (e.g., name, email). 3. Insert placeholders using **double curly brackets** around descriptive keys. Examples: * Employee first name: `{{employee.first_name}}` * Employee last name: `{{employee.last_name}}` * Employee email: `{{employee.email}}` 4. Define the location for the employee signature clearly by inserting a signature placeholder using **double square brackets**, e.g.: `[[employee_signature]]` 5. Define the location for the employer signature clearly by inserting a signature placeholder using **double square brackets**, e.g.: `[[employer_signature]]` 6. Add a place for the salary amount that the employer will fill during the signature process, e.g.: `[[salary_input]]` **Example placeholder usage in your document:** > *Dear `{{employee.first_name}}` `{{employee.last_name}}`,* > *This will be the salary amount you will receive per month: `[[salary_input]]`* > *Employer Signature:* > `[[employer_signature]]` > *Employee Signature:* > `[[employee_signature]]` 7. Save your template and upload it to **OneDrive** (or another preferred storage service). **Important:** Ensure placeholder keys match exactly with what you'll use later in Power Automate. Keep your template simple and clear to avoid confusion during dynamic insertion. Word Template Example ### Step 2: Create the Microsoft Form Create a Microsoft Form to collect necessary employee details (First Name, Last Name, Email Address). 1. Visit [Microsoft Forms](https://forms.office.com) and sign in. 2. Click **New Form**. New Form 3. Name the form and add the following required questions: * **First Name** (Text, required) * **Last Name** (Text, required) * **Email Address** (Text, required) Add request Rename form 4. Save and publish your form. Employee Form ### Step 3: Create the Dataverse Table Create a Dataverse table to store the employee details from the form and signature completion. 1. Go to [Power Apps](https://make.powerapps.com) and sign in. 2. From the left menu, click on **Tables**. 3. Click the **Start with a blank table** button. Start with a blank table 4. Edit the New column and rename it to **First Name**. Click on the column name, then on **Edit column**, and rename it from the **Display name** field. Rename column 5. Add the following columns: * **Last Name** (Text) * **Email Address** (Text) * **Salary Amount** (Text) * **Signature Completion** (Text) Add columns 6. Rename the table from the **Properties** button (e.g., **Employee Contracts**) and click on the **Save and exit** button. Rename table ### Step 4: Set Up the Power Automate Flow Now, create the automated workflow in Power Automate, triggered whenever a form is submitted. #### 4.1 Configure the Trigger Set the flow trigger to run whenever your form is submitted. 1. Go to **Power Automate** and select **Automated Cloud Flow**. 2. Choose the trigger **When a new response is submitted** (Microsoft Forms). Trigger 3. Select the form you created earlier. Select form #### 4.2 Retrieve Employee Details Retrieve the employee details submitted through the form. 1. Add the action **Get response details**. 2. Select your form (**Form ID**) and the response (**Response ID**) using dynamic content. Get response details #### 4.3 Retrieve Contract Template from OneDrive Fetch your employment contract template stored in OneDrive. 1. Add **Get File Content using Path** from the OneDrive connector. 2. Select the DOCX template stored in your OneDrive. Get file content ### Step 5: Set Up the Signature Process In this step, you will configure SignatureAPI to create, send, and track the signature process. #### 5.1 Create a SignatureAPI Envelope Begin by creating an envelope to hold your contract and signature process. 1. Add the **Create an Envelope** action (SignatureAPI connector). 2. If prompted, authenticate your connection using your SignatureAPI key from the [SignatureAPI Dashboard](https://dashboard.signatureapi.com/settings/api-keys). 3. Set an **Envelope Title** (e.g., employee name) and email message using dynamic content. 4. From the advanced parameters, select **Envelope Routing** and set it to **sequential**. This ensures the envelope is sent to the employer first, and then to the employee. Envelope routing #### 5.2 Add the Recipient - Employer Specify who will receive and sign the contract first. 1. Add **Add Recipient** action and rename it to **Add Recipient - Employer**. 2. Set the **Recipient Name** and **Recipient Email** of the employer (e.g., "John Doe" and "[john.doe@example.com](mailto:john.doe@example.com)"). 3. Set the employer **Recipient Key** (e.g., "employer"), matching your DOCX placeholders. Add recipient employer #### 5.3 Add the Recipient - Employee Specify the employee who will receive and sign the contract. 1. Add **Add Recipient** action and rename it to **Add Recipient - Employee**. 2. Set the **Recipient Name** and **Recipient Email** using form details (Dynamic Content). 3. Set the employee **Recipient Key** (e.g., "employee"), matching your DOCX placeholders. Add recipient employee #### 5.4 Attach the DOCX Contract Template Attach your contract template to the envelope and populate it with employee details. 1. Add **Add a Template - DOCX** action. 2. Select **File Content** from the OneDrive action. 3. Set the **Document Title** (e.g., "Employment Contract"). 4. Ensure your DOCX template uses placeholders (`{{employee.first_name}}`, `{{employee.last_name}}`, `{{employee.email}}`, etc.) and map each field to the corresponding dynamic content from your form. Add template #### 5.5 Define Signature Placement - Employer Specify where the employer should sign on the document. 1. Add **Add a Place - Signature** action and rename it to **Add a Place - Employer Signature**. 2. Set the **Document ID** using dynamic content. 3. Use the placeholder (e.g., `[[employer_signature]]`) from your DOCX template. 4. Set the **Recipient Key** using the **Add Recipient - Employer** action from the dynamic content. Add place employer #### 5.6 Define Text Input Placement - Salary Input Specify where the employer should fill the salary amount. 1. Add **Add a Place - Text Input** action and rename it to **Add a Place - Salary Input**. 2. Use the placeholder (e.g., `[[salary_input]]`) from your DOCX template. 3. Set the **Recipient Key** using the **Add Recipient - Employer** action from the dynamic content. This ensures the salary amount is defined and completed in the signature process by the employer. 4. From the advanced parameters, set **Capture As** to `salary_input`. This ensures that the salary amount is captured as text, allowing you to retrieve it later in the flow. Add place salary #### 5.7 Define Signature Placement - Employee Specify where the employee should sign on the document. 1. Add **Add a Place - Signature** action and rename it to **Add a Place - Employee Signature**. 2. Use the placeholder for the **Place Key** (e.g., `[[employee_signature]]`) from your DOCX template. 3. Set the **Document ID** using dynamic content. 4. Set the **Recipient Key** using the **Add Recipient - Employee** action from the dynamic content. Add place employee #### 5.8 Start the Signing Process Trigger the sending of your envelope for signing. 1. Add **Start Envelope** action. 2. Set the **Envelope ID** using the dynamic content from the **Create an Envelope** action. Start envelope ### Step 6: Monitor and Finalize the Contract Configure your flow to wait for the signing to complete, retrieve the signed contract, store the data, and notify HR. #### 6.1 Wait for Signature Completion Pause the flow until both parties have signed the contract. 1. Add **Wait for Envelope Completion** action. 2. Set the **Envelope ID** using the dynamic content from the **Create an Envelope** action. Wait for envelope completion #### 6.2 Get Captured Value Once signed, automatically retrieve the captured salary value. 1. Add **Get a captured value** action from the SignatureAPI connector. 2. Set the **Envelope ID** using the dynamic content from the **Create an Envelope** action. 3. Select the correct **Captured Key**, which must match the one defined earlier (`salary_input`) to retrieve the salary amount filled by the employer. Get captured value #### 6.3 Add a Row to Dataverse Add a row to the Dataverse table with the employee details and the captured salary amount. 1. Add **Add a new row** action from the Dataverse connector. 2. Select the correct **Dataverse Table**, which must match the one you created earlier. 3. From the **Advanced parameters**, select the **Fields** to map to the employee details and the captured salary amount from the dynamic content. * Set **First Name**, **Last Name**, and **Email Address** from the form response details. * Set **Salary Amount** from the captured value from the **Get a captured value** action. * Set **Signature Completion** from the **Wait for Envelope Completion** action. Add row #### 6.4 Retrieve the Signed Contract Retrieve the completed document. 1. Add **Get a Deliverable** action. 2. Select the correct **Deliverable ID** using dynamic content. Get deliverable #### 6.5 Save the Signed Contract to OneDrive Save the signed document for record-keeping. 1. Add **Create File** action (OneDrive connector). 2. Set the folder path and filename (ending in `.pdf`). 3. Map **File Content** from the deliverable. Save file #### 6.6 Notify HR via Email Automatically inform HR that the contract has been signed and saved. 1. Add **Send an Email** action (Outlook connector). 2. Configure the email recipient (HR), subject, and message. 3. Attach the signed contract file from dynamic content. Use the **File Content** from the **Get a Deliverable** action, and set the filename (ending in `.pdf`). Send email ### Step 7: Test Your Automation Finally, test the entire process end-to-end. 1. Save your Power Automate flow. 2. Submit a test response through your Microsoft Form. 3. Verify the following: * The form is submitted successfully. * The flow is triggered and the contract is sent to the employer. * After the employer fills the salary amount and signs the contract, the employee receives the contract and signs it. * A row is added to the Dataverse table with the employee details and the captured salary amount. * The signed contract is saved successfully in OneDrive. * HR receives an email notification with the signed contract attached. *Use the following checklist:* * [ ] Contract sent successfully. * [ ] Employer fills the salary amount and signs the contract. * [ ] Employee receives and signs the contract. * [ ] A row is added to the Dataverse table with the employee details and the captured salary amount. * [ ] Signed document stored correctly in OneDrive. * [ ] HR receives email notification with attachment. ## Troubleshooting & FAQ ### Common Issues: * **API Key Errors:** Ensure your SignatureAPI key is correct and authenticated. * **Dynamic Content Mapping:** Double-check that placeholder naming in your DOCX file matches exactly with dynamic content mappings. * **File Access Issues:** Verify permissions and file paths in OneDrive. ### Frequently Asked Questions: * *What if the contract isn't sent?* Check your SignatureAPI dashboard for errors and verify recipient details. * *Can I adapt this for other document types?* Yes, this method is adaptable for any automated document-signing workflow. * *What if the Dataverse row is not added?* Verify that the Dataverse table columns match the fields you configured in the flow, and confirm that the captured key matches the one defined in the text input place. ## Best Practices & Security * Always securely manage API keys. * Regularly check flow runs in Power Automate for any errors. * Document any flow or template changes for future reference. ## Additional Resources * [SignatureAPI Documentation](https://signatureapi.com/docs) * [Microsoft Forms Help](https://support.microsoft.com/forms) * [Microsoft Dataverse Documentation](https://www.microsoft.com/en-us/power-platform/dataverse) * [Power Automate Community](https://powerusers.microsoft.com/t5/Microsoft-Power-Automate/ct-p/MPACommunity) ## Conclusion By completing this tutorial, you have successfully automated the process of sending, signing, and managing employment contracts with data stored in Microsoft Dataverse. This workflow frees your HR team from repetitive tasks and ensures new employees have a smooth onboarding experience. **Happy Automating!** # Automating Employment Contracts with Microsoft Forms, SignatureAPI, and Microsoft Power Automate Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/envelope-form-through-microsoft-forms Automate employment contract signing when form submissions are received in Microsoft Forms ## Overview This tutorial shows you how to streamline the employment contract process by automatically sending, signing, and storing contracts. By integrating **Microsoft Forms** (for data collection), **OneDrive** (for storing contract templates), and the **SignatureAPI connector** (for electronic signatures), you can eliminate manual errors and delays when onboarding new employees. ### What You'll Learn * How to trigger a flow with a new Microsoft Forms response. * Retrieving and pre-filling a DOCX contract template from OneDrive. * Creating and sending a signature envelope using SignatureAPI. * Monitoring the signing process and retrieving the signed document. * Saving the signed contract and notifying HR automatically. ### The Problem HR departments often struggle with manually handling contracts, causing delays in onboarding. Common issues include: * **Slow processing** that delays new hire start dates. * **Errors** from manual data entry across multiple documents. * **Tracking difficulty** when monitoring signing status across teams. ### How Automation Helps Automation simplifies this process by: * Automatically sending contracts upon form submission. * Using templates pre-filled with employee details. * Tracking signature status and storing documents automatically. * Informing HR instantly once contracts are signed. ## Requirements Before starting, make sure you have: * **Power Automate** to build workflows. * **SignatureAPI account** for electronic signatures. * **Microsoft Forms** for collecting employee information. * **OneDrive** for storing your DOCX templates. * **Outlook** for sending notifications (other email providers also work). ## Flow Overview The automation process follows these steps: 1. **Trigger:** Microsoft Forms submission starts the flow. 2. **Data Retrieval:** Get employee details and fetch the contract template from OneDrive. 3. **Signature Process:** Create an envelope via SignatureAPI, add recipient details, and attach the DOCX. 4. **Monitoring:** Wait for the contract to be signed. 5. **Storage & Notification:** Save the signed document in OneDrive and notify HR via email. Here's what your final Power Automate flow will look like: Flow ## Step-by-Step Tutorial Follow these steps to automate your employment contract process using Microsoft Forms, SignatureAPI, and Power Automate: ### Step 1: Prepare the Contract Template First, create or update your employment contract template by adding placeholders for dynamic fields (employee details) and defining where the employee will sign. **To prepare your template:** 1. Open your existing employment contract document (DOCX format) in Microsoft Word. 2. Identify each place where employee details should be dynamically inserted (e.g., name, email). 3. Insert placeholders using **double curly brackets** around descriptive keys. Examples: * Employee first name: `{{employee.first_name}}` * Employee last name: `{{employee.last_name}}` * Employee email: `{{employee.email}}` 4. Define the location for the signature clearly by inserting a signature placeholder using **double square brackets**, e.g.: `[[employee_signature]]` **Example placeholder usage in your document:** > *Dear `{{employee.first_name}}` `{{employee.last_name}}`,* > *Please review and sign your employment contract below:* > `[[employee_signature]]` 5. Save your template and upload it to **OneDrive** (or another preferred storage service). **Important:** * Ensure placeholder keys match exactly with what you'll use later in Power Automate. * Keep your template simple and clear to avoid confusion during dynamic insertion. Word Template Example ### Step 2: Create the Microsoft Form Create a Microsoft Form to collect the necessary employee details (First Name, Last Name, Email Address). 1. Visit [Microsoft Forms](https://forms.office.com) and sign in. 2. Click **New Form**. New Form 3. Name the form and add these required questions: * **First Name** (Text, required) * **Last Name** (Text, required) * **Email Address** (Text, required) Add request Rename form 4. Save and publish your form. Employee Form ### Step 3: Set Up the Power Automate Flow Now, create the automated workflow in Power Automate, triggered whenever a form is submitted. #### 3.1 Configure the Trigger Set the flow trigger to run whenever your form is submitted. 1. Go to **Power Automate** and select **Automated Cloud Flow**. 2. Choose the trigger **When a new response is submitted** (Microsoft Forms). Trigger 3. Select the form you created earlier. Select form #### 3.2 Retrieve Employee Details Next, retrieve the employee details submitted through the form. 1. Add the action **Get response details**. 2. Select your form (**Form ID**) and the response (**Response ID**) from Dynamic Content. Get response details #### 3.3 Retrieve Contract Template from OneDrive Fetch your employment contract template stored in OneDrive. 1. Add **Get File Content using Path** from the OneDrive connector. 2. Select the DOCX template stored in your OneDrive. Get file content ### Step 4: Set Up the Signature Process In this step, you will configure SignatureAPI to create, send, and track the signature process. #### 4.1 Create a SignatureAPI Envelope Begin by creating an envelope to hold your contract and signature process. 1. Add the **Create an Envelope** action (SignatureAPI connector). 2. If prompted, authenticate your connection using your SignatureAPI key from the [SignatureAPI Dashboard](https://dashboard.signatureapi.com/settings/api-keys). 3. Set an **Envelope Title** (e.g., employee name) and email message using dynamic content. Create envelope #### 4.2 Add the Recipient Specify who will receive and sign the contract. 1. Add the **Add Recipient** action. 2. Map **Recipient Name** and **Recipient Email** using form details (Dynamic Content). 3. Set the **Recipient Key** (e.g., `employee`), matching your DOCX placeholders. Add recipient #### 4.3 Attach the DOCX Contract Template Attach your contract template to the envelope and populate it with employee details. 1. Add the **Add a Template - DOCX** action. 2. Select **File Content** from the OneDrive action. 3. Set the **Document Title** (e.g., "Employment Contract"). 4. Ensure your DOCX template uses placeholders (`{{employee.first_name}}`, etc.) and map each field to the corresponding dynamic content from your form. Add template #### 4.4 Define Signature Placement Specify where the employee should sign on the document. 1. Add the **Add a Place - Signature** action. 2. Set the **Document ID** using dynamic content. 3. Use the placeholder (e.g., `[[employee_signature]]`) from your DOCX template. 4. Set the **Recipient Key** using dynamic content. Add signature #### 4.5 Start the Signing Process Send your envelope to the employee for signing. 1. Add the **Start Envelope** action. 2. Select the appropriate **Envelope ID** using dynamic content. Start envelope ### Step 5: Monitor and Finalize the Contract Configure your flow to wait for the signing to complete, retrieve the signed contract, and notify HR. #### 5.1 Wait for Signature Completion Pause the flow until the employee signs the contract. 1. Add the **Wait for Envelope Completion** action. 2. Select the correct **Envelope ID** using dynamic content. Wait for envelope completion #### 5.2 Retrieve the Signed Contract Once signed, automatically retrieve the completed document. 1. Add the **Get a Deliverable** action. 2. Select the correct **Deliverable ID** using dynamic content. Get deliverable #### 5.3 Save the Signed Contract to OneDrive Save the signed document for record-keeping. 1. Add the **Create File** action (OneDrive connector). 2. Set the folder path and filename (ending in `.pdf`). 3. Map **File Content** from the deliverable. Save file #### 5.4 Notify HR via Email Automatically inform HR that the contract has been signed and saved. 1. Add the **Send an Email** action (Outlook connector). 2. Configure the email recipient (HR), subject, and message. 3. Attach the signed contract file from dynamic content. Use the **File Content** from the **Get a Deliverable** action, and set the filename (ending in `.pdf`). Send email ### Step 6: Test Your Automation Finally, test the entire process end-to-end. 1. Save your Power Automate flow. 2. Submit a test response through your Microsoft Form. 3. Verify: * Contract is sent to the employee. * Signature process initiates correctly. * Signed contract saves successfully in OneDrive. * HR receives an email notification with the signed contract attached. *Use the following checklist:* * [ ] Contract sent successfully. * [ ] Employee receives and signs contract. * [ ] Signed document stored correctly in OneDrive. * [ ] HR receives email notification with attachment. ## Troubleshooting & FAQ ### Common Issues * **API Key Errors:** Ensure your SignatureAPI key is correct and authenticated. * **Dynamic Content Mapping:** Double-check that placeholder names in your DOCX file match exactly with dynamic content mappings in Power Automate. * **File Access Issues:** Verify permissions and file paths in OneDrive. ### Frequently Asked Questions * *What if the contract is not sent?* Check your SignatureAPI dashboard for errors, and verify the recipient details are mapped correctly from the form response. * *Can I adapt this for other document types?* Yes. This method works for any automated document-signing workflow, such as NDAs, vendor agreements, or offer letters. * *Can I collect additional fields in Microsoft Forms and use them in my contract template?* Yes. Add new questions to your Microsoft Form, then insert matching placeholders (e.g., `{{employee.department}}`) in your DOCX template. In the **Add a Template - DOCX** action, map each new placeholder to the corresponding form response using Dynamic Content. ## Best Practices & Security * Always securely manage API keys. * Regularly check flow runs in Power Automate for any errors. * Document any flow or template changes for future reference. ## Additional Resources * [SignatureAPI Documentation](https://signatureapi.com/docs) * [Microsoft Forms Help](https://support.microsoft.com/forms) * [Power Automate Community](https://powerusers.microsoft.com/t5/Microsoft-Power-Automate/ct-p/MPACommunity) ## Conclusion By completing this tutorial, you have successfully automated the process of sending, signing, and managing employment contracts. This workflow frees your HR team from repetitive tasks and ensures new employees have a smooth onboarding experience. **Happy Automating!** # Automating Customer Agreements with Power Apps, SignatureAPI, and Power Automate Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/envelope-form-through-power-app Build a Power Apps form that triggers automated customer agreement signing workflows using SignatureAPI and Microsoft Power Automate. ## Overview This tutorial shows you how to streamline customer agreement signing by automatically sending, signing, and storing agreements. By integrating **Power Apps** (for data collection), **SharePoint Documents** (for storing contract templates), and the **SignatureAPI connector** (for electronic signatures), you can eliminate manual errors and delays in your customer agreements workflow. ### What You'll Learn * How to trigger a flow from a Power Apps form submission. * Retrieving and pre-filling a DOCX contract template from SharePoint. * Creating and sending a signature envelope using SignatureAPI. * Monitoring the signing process and retrieving the signed document. * Saving the signed contract and automatically notifying the business. ### The Problem Businesses often struggle with manually handling customer agreements, causing delays in customer onboarding. Common issues include: * **Slow processing** caused by manual, repetitive tasks. * **Errors** from manual data entry and document handling. * **Tracking difficulty** when monitoring signing status across multiple agreements. ### How Automation Helps Automation simplifies this process by: * Automatically sending agreements when a Power Apps form is submitted. * Using templates pre-filled with customer details. * Tracking signature status and storing documents automatically. * Instantly informing the business once agreements are signed. ## Requirements Before starting, make sure you have: * **Power Automate** for building workflows. * **SignatureAPI account** for electronic signatures. * **Power Apps** for collecting customer information. * **SharePoint Documents** for storing your DOCX templates. * **Outlook** for sending notifications (other email providers also work). ## Flow Overview The automation process follows these steps: 1. **Trigger:** A Power Apps form submission starts the flow. 2. **Data Retrieval:** Get customer details and fetch the agreement template from SharePoint Documents. 3. **Signature Process:** Create an envelope via SignatureAPI, add recipient details, and attach the DOCX template. 4. **Monitoring:** Wait for the agreement to be signed. 5. **Storage and Notification:** Save the signed document in SharePoint and notify the business via email. Here is what your final Power Automate flow will look like. Note that the flow is created from Power Apps, but you can also view it from the Power Automate Dashboard. Flow ## Step-by-Step Tutorial Follow these steps to automate your customer agreements signing process using Power Apps, SignatureAPI, and Microsoft Power Automate. ### Step 1: Prepare the Agreement Template First, create or update your agreement template by adding placeholders for dynamic fields (customer details) and defining where the customer will sign. **To prepare your template:** 1. Open your existing customer agreement document (DOCX format) in Microsoft Word. 2. Identify each place where customer details should be dynamically inserted (e.g., name, email). 3. Insert placeholders using **double curly brackets** around descriptive keys. Examples: * Customer name: `{{customer.name}}` * Customer email: `{{customer.email}}` 4. Define the location for the signature clearly by inserting a signature placeholder using **double square brackets**, e.g.: `[[customer_signature]]` **Example placeholder usage in your document:** > *Dear `{{customer.name}}`,* > *Please review and sign your agreement below:* > `[[customer_signature]]` 5. Save your template and upload it to **Documents** in the **SharePoint Site**. **Important:** * Ensure placeholder keys match exactly with what you will use later in Power Automate. * Keep your template simple and clear to avoid confusion during dynamic insertion. Word Template Example ### Step 2: Create a Power App and Initialize Variables First, create a Power App to collect the necessary customer details (Name, Email Address). 1. Visit [Power Apps](https://make.powerapps.com) and sign in. 2. Create a new **Blank Canvas App** and choose the format type. For this example, choose the **Phone** format. New Power App 3. From the left-hand menu bar, click on the three dots, select **Power Automate**, and select **Create New Flow**. New Power Automate Flow 4. Select **Create From Blank**. 5. Enter a name for the Flow. Notice that Power Apps has automatically been selected to trigger the Flow. Trigger 6. Click on the trigger (**Power Apps (V2)**) and select **Add an input**. Add Input 7. Select the **Text** type and enter a name for the input (for example, `Customer Name`). Repeat this for the other variable (`Customer Email`). Text Input 8. Add a new step and select the **Initialize Variable** action. * Select the three dots and **Rename** this step according to the variable name (for example, `Customer Name`) before filling out any of the required fields. This will properly name the variable's Dynamic Content value later on. If the step is not renamed, the value will automatically be named "InitializeVariable\_Value." * Enter the variable **Name**. * Use the **Type** drop-down menu and select **String** as the variable type. * Click in the **Value** field and select the `Customer Name` variable from the Dynamic Content list. This allows you to pass in a parameter associated with this variable in Power Apps. * Repeat these steps to initialize the other variable (`Customer Email`). Initialize Variable ### Step 3: Retrieve Contract Template from SharePoint Now, fetch your customer agreement template stored in SharePoint. 1. Add **"Get File Content using Path"** from the SharePoint connector. 2. Select the DOCX template stored in your SharePoint. Get File Content ### Step 4: Create the Envelope with SignatureAPI In this step, you will configure SignatureAPI to create, send, and track the signature process. #### 4.1 Create a SignatureAPI Envelope Begin by creating an envelope to hold your contract and signature process. 1. Add a new step with the **"Create an Envelope"** action (SignatureAPI connector). 2. If prompted, authenticate your connection using your SignatureAPI key from the [SignatureAPI Dashboard](https://dashboard.signatureapi.com/settings/api-keys). 3. Set an **Envelope Title** (e.g., customer name) and email message using dynamic content. Create envelope #### 4.2 Add the Recipient Next, specify who will receive and sign the contract. 1. Add the **"Add Recipient"** action. 2. Map **Recipient Name** and **Recipient Email** using form details (Dynamic Content). 3. Set the **Recipient Key** (e.g., "customer"), matching your DOCX placeholders. Add recipient #### 4.3 Attach the DOCX Contract Template Now, attach your contract template to the envelope and populate it with customer details. 1. Add the **"Add a Template - DOCX"** action. 2. Select **File Content** from the SharePoint action. 3. Set the **Document Title** (e.g., "Customer Agreement"). 4. Ensure your DOCX template uses placeholders (`{{customer.name}}`, etc.) and map each field to the corresponding dynamic content from the Power Apps initialized variables. Add template #### 4.4 Define Signature Placement Specify where the customer should sign on the document. 1. Add the **"Add a Place - Signature"** action. 2. Set the **Document ID** using dynamic content. 3. Use the placeholder (e.g., `[[customer_signature]]`) from your DOCX template. 4. Set the **Recipient Key** using dynamic content. Add signature #### 4.5 Start the Signing Process Trigger the sending of your envelope to the customer for signing. 1. Add the **"Start Envelope"** action. 2. Select the appropriate **Envelope ID** using dynamic content. Start envelope ### Step 5: Monitor and Finalize the Contract Next, configure your flow to wait for the signing to complete, retrieve the signed contract, and notify the business. #### 5.1 Wait for Signature Completion Pause the flow until the customer signs the contract. 1. Add the **"Wait for Envelope Completion"** action. 2. Select the correct **Envelope ID** using dynamic content. Wait for envelope #### 5.2 Retrieve the Signed Contract Once signed, automatically retrieve the completed document. 1. Add the **"Get Deliverables"** action. 2. Select the correct **Deliverable ID** using dynamic content. Get deliverable #### 5.3 Save the Signed Contract to SharePoint Save the signed document for record-keeping. 1. Add the **"Create File"** action (SharePoint connector). 2. Select the **Site Address** and **Folder Path**. 3. Set the **File Name** (ending in `.pdf`). 4. Map **File Content** from the deliverable. Save file #### 5.4 Notify the Business via Email Automatically inform the business that the contract has been signed and saved. 1. Add the **"Send an Email"** action (Outlook connector). 2. Configure the email recipient, subject, and message. 3. Attach the signed contract file from dynamic content. Send email #### 5.5 Save the Flow Save the flow by clicking the **Save** button in the top left corner. This will save the flow to Power Automate and add it to the Power App. ### Step 6: Create the Text Inputs in Power Apps Create the text inputs in the Power App to collect the customer details. 1. Select **Insert** in the top menu bar and then select **Label**. 2. Change the **Text** value of this label to "Name:" You can do this in either the top function bar or through the **Text** property in the right-hand menu. Label 3. Select **Input** from the top menu bar and select **Text input** from the drop-down menu. * Repeat these steps to create the other text input fields for the other variable (`Customer Email`). **Tip:** Select the text input bar. Notice the element name has been highlighted in the left-hand Tree view. Click the three dots on this element and **Rename** it to match the text label (in this case, "Name"). This will make it easier to identify this element later when you reference its value to trigger the Flow. Text Input Text Input 5. Select **Button** from the top menu bar. * Enter `Submit` in the **Text** property on the right-hand menu. * Position this button below the text input fields. Button 6. Select the newly created **Submit** button. * Select **OnSelect** from the drop-down menu in the upper left-hand corner. * In the function bar, enter: `FlowName.Run(name.Text, email.Text)`. This triggers the Power Automate Flow and passes in the text input fields as parameters that reference the variables initialized in the Flow. Button Submit **Important:** Power Apps expects a certain order for the parameters and displays an example `.Run()` function call with the variable names as parameter placeholders. Make sure the order of the parameters matches the expected order to prevent invalid argument errors. **Note:** By renaming the text input field elements in Step 6, you can easily reference them when passing them into the `.Run()` function as parameters. Power Apps also color-codes each text input field to its corresponding parameter value. ### Step 7: Test Your Automation Finally, test the entire process end-to-end. 1. Select the **Preview** button in the upper-right hand corner to fill out the text input fields with recipient information and trigger the Flow by clicking the **Submit** button. Preview 2. Submit a test response by clicking on the **Submit** button. Preview 3. Verify: * The contract is sent to the customer via email. * The signature process initiates correctly. * The signed contract saves successfully in SharePoint. * The business receives an email notification with the signed contract attached. *Use the following checklist:* * [ ] Contract sent successfully. * [ ] Customer receives and signs contract. * [ ] Signed document stored correctly in SharePoint. * [ ] Business receives email notification with attachment. ## Troubleshooting & FAQ ### Common Issues * **API Key Errors:** Ensure your SignatureAPI key is correct and authenticated. * **Dynamic Content Mapping:** Double-check that placeholder names in your DOCX file match exactly with the dynamic content mappings in your flow. * **File Access Issues:** Verify permissions and file paths in SharePoint. ### Frequently Asked Questions * **What if the agreement is not sent?** Check your SignatureAPI dashboard for errors and verify the recipient details. Also confirm that the Power Apps trigger is passing parameters correctly to the flow. * **Can I add more fields to the Power Apps form?** Yes. Add additional text inputs in Power Apps, initialize corresponding variables in the flow, and map them to DOCX template placeholders. Update the `.Run()` function call to include the new parameters in the correct order. * **How do I handle multiple signers?** Add additional **Add Recipient** and **Add a Place - Signature** actions in your flow for each signer. Each signer needs a unique recipient key that matches the corresponding placeholders in your DOCX template. * **Can I use a gallery or dropdown instead of text inputs?** Yes. Power Apps supports various input controls. As long as you pass the correct `.Text` or `.Selected` values into the `.Run()` function, the flow will receive the data it needs. ## Best Practices and Security * Always securely manage API keys. * Regularly check flow runs in Power Automate for any errors. * Document any flow or template changes for future reference. ## Additional Resources * [SignatureAPI Documentation](https://signatureapi.com/docs) * [Microsoft Power Apps Documentation](https://www.microsoft.com/power-platform/power-apps-documentation) * [Power Automate Community](https://powerusers.microsoft.com/t5/Microsoft-Power-Automate/ct-p/MPACommunity) * [SharePoint Documentation](https://support.microsoft.com/sharepoint) ## Conclusion By completing this tutorial, you have successfully automated the process of sending, signing, and managing customer agreements. This workflow frees your business from repetitive tasks and ensures customer agreements are signed efficiently and stored automatically. **Happy Automating!** # Automating Employment Contracts with SharePoint List, SignatureAPI and Microsoft Power Automate Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/envelope-new-item-sharepoint-list Trigger contract signing automatically when new items are added to SharePoint lists ## Overview This tutorial demonstrates how to streamline the employment contract process by automatically sending, signing, and storing contracts. By integrating **SharePoint List** (for storing the onboarding pack with employee details), **SignatureAPI connector** (for electronic signatures), and **Power Automate** (for the approval-and-signature workflow), you can eliminate manual errors and delays in onboarding new employees. ### What You'll Learn * How to trigger a flow with a new SharePoint List item. * Retrieving and pre-filling a DOCX contract template from SharePoint List. * Creating and sending a signature envelope using SignatureAPI. * Monitoring the signing process and retrieving the signed document. * Saving the signed contract and notifying HR automatically. ### The Problem HR departments often struggle with manually handling contracts, causing delays in onboarding. Common issues include: * **Slow processing** caused by manual tasks and handoffs. * **Errors** from manual data entry across multiple systems. * **Tracking difficulty** when monitoring signing status across employees. ### How Automation Helps Automation simplifies this process by: * Automatically sending contracts to the employee. * Using templates pre-filled with employee details. * Tracking signature status and storing documents automatically. * Informing HR instantly once contracts are signed. ## Requirements Before starting, make sure you have: * **Power Automate** to build workflows. * **SignatureAPI account** for electronic signatures. * **SharePoint List** for storing the onboarding pack with employee details. * **Outlook** for sending notifications (other email providers also work). ## Flow Overview The automation process follows these steps: 1. **Trigger:** New SharePoint List item creation starts the flow. 2. **Data Retrieval:** Get the onboarding pack with employee details and fetch the contract template from SharePoint List. 3. **Signature Process:** Create an envelope via SignatureAPI, add recipient details, and attach the DOCX. 4. **Monitoring:** Wait for the contract to be signed. 5. **Storage & Notification:** Save the signed document in SharePoint and notify HR via email. This process automates envelope creation and sending when a new item with an attachment is added to the SharePoint List. Here's what your final Power Automate flow will look like: Flow ## Step-by-Step Tutorial Follow these steps to automate your employment contract process using SharePoint List, SignatureAPI, and Microsoft Power Automate: ### Step 1: Prepare the Contract Template First, create or update your employment contract template by adding placeholders for dynamic fields (employee details) and defining where the employee will sign. **To prepare your template:** 1. Open your existing employment contract document (DOCX format) in Microsoft Word. 2. Identify each place where employee details should be dynamically inserted (e.g., first name, last name, email). 3. Insert placeholders using **double curly brackets** around descriptive keys. Examples: * Employee first name: `{{employee.first_name}}` * Employee last name: `{{employee.last_name}}` * Employee email: `{{employee.email}}` 4. Define the location for the signature clearly by inserting a signature placeholder using **double square brackets**, e.g.: `[[employee_signature]]` **Example placeholder usage in your document:** > *Dear `{{employee.first_name}}` `{{employee.last_name}}`,* > *Please review and sign your employment contract below:* > `[[employee_signature]]` 5. Save your template. **Important:** * Ensure placeholder keys match exactly with what you'll use later in Power Automate. * Keep your template simple and clear to avoid confusion during dynamic insertion. Word Template Example ### Step 2: Create the SharePoint List First, create a SharePoint List to store the employee details. 1. Visit [Microsoft Lists](https://www.microsoft.com/en-us/microsoft-365/microsoft-lists) and sign in. 2. Click on **"New List"** and then click on **"Blank List"**. New List 3. Rename the list, and save it to the SharePoint Site. Rename List 4. Add the following columns: * **First Name** (Text) * **Last Name** (Text) * **Email Address** (Text) Add Columns Add Columns 5. Save and publish the list. ### Step 3: Set Up the Power Automate Flow Now, create the automated workflow in Power Automate, triggered whenever a new item with an attachment is added to the SharePoint List. #### 3.1 Configure the Trigger First, set the flow trigger to run whenever a new item is added to the SharePoint List. 1. Go to **Power Automate** and select **Automated Cloud Flow**. 2. Add Trigger. Name your flow, select **"When an item is created"** from the SharePoint connector, and then click **Create**. Trigger 3. Select the Site Address and the list you created earlier. Select List #### 3.2 Retrieve Employee Details from SharePoint List Next, retrieve the employee details from the SharePoint List. 1. Add the action **"Get attachments"** from the SharePoint connector. 2. Select the Site Address, List Name and Item ID from the previous step with dynamic content. Get Attachments #### 3.3 Get file content 1. Add the **"Get file content"** action from the SharePoint connector. 2. Select the Site Address. 3. Add to the File Identifier the ID from the **Get attachments** step with dynamic content. Get file content Note: Power Automate will automatically add this to an Apply Each loop. This just means it will loop through all attachments you make to the item. This won't affect the behavior, as you're only attaching one document. If more attachments are added to any item, it's important that the document has the same fields as the template. ### Step 4: Set Up the Signature Process In this step, you'll configure SignatureAPI to create, send, and track the signature process. #### 4.1 Create a SignatureAPI Envelope Begin by creating an envelope to hold your contract and signature process. 1. Add the **"Create an Envelope"** action (SignatureAPI connector). 2. If prompted, authenticate your connection using your SignatureAPI key from the [SignatureAPI Dashboard](https://dashboard.signatureapi.com/settings/api-keys). 3. Set an **Envelope Title** (e.g., employee first name) and a message using dynamic content. Create envelope #### 4.2 Add the Recipient Next, specify who will receive and sign the contract. 1. Outside the **"For each loop"**, add **"Add Recipient"** action from the SignatureAPI connector. 2. Map **Recipient Name** and **Recipient Email** using form details (Dynamic Content). 3. Set the **Recipient Key** (e.g., "employee"), matching your DOCX placeholders. Add recipient #### 4.3 Attach the DOCX Contract Template Now, attach your contract template to the envelope and populate it with employee details. 1. Add **"Add a Template – DOCX"** action. 2. Select **File Content** from the **Get file content** action. 3. Select the Envelope ID from the **Create an Envelope** action. 4. Set the **Document Title** (e.g., "Employment Contract"). 5. Ensure your DOCX template uses placeholders (`{{employee.first_name}}`, etc.) and map each field to the corresponding dynamic content from your form. Add template #### 4.4 Define Signature Placement Specify where the employee should sign on the document. 1. Add **"Add a Place – Signature"** action. 2. Set the **Document ID** using dynamic content. 3. Use the placeholder (e.g., `[[employee_signature]]`) from your DOCX template. 4. Set the **Recipient Key** using dynamic content. Add signature #### 4.5 Start the Signing Process Trigger the sending of your envelope to the employee for signing. 1. Add **"Start Envelope"** action from the SignatureAPI connector. 2. Select the appropriate **Envelope ID** using dynamic content. Start envelope ### Step 5: Monitor and Finalize the Contract Next, configure your flow to wait for the signing to complete, retrieve the signed contract, and notify HR. #### 5.1 Wait for Signature Completion Pause the flow until the employee signs the contract. 1. Add **"Wait for Envelope Completion"** action from the SignatureAPI connector. 2. Select the correct **Envelope ID**. Wait for envelope #### 5.2 Retrieve the Signed Contract Once signed, automatically retrieve the completed document. 1. Add **"Get a Deliverable"** action from the SignatureAPI connector. 2. Select the correct **Deliverable ID** using dynamic content. Get deliverable #### 5.3 Save the Signed Contract to SharePoint Save the signed document for record-keeping. 1. Add **"Create File"** action (SharePoint connector). 2. Select the **Site Address** and **Folder Path**. 3. Set the **File Name** (ending in `.pdf`). 4. Map **File Content** from the deliverable. Save file #### 5.4 Notify HR via Email Automatically inform HR that the contract has been signed and saved. 1. Add **"Send an Email"** action (Outlook connector). 2. Configure the email recipient (HR), subject, and message. 3. Attach the signed contract file from dynamic content. Send email ### Step 6: Test Your Automation Finally, test the entire process end-to-end. 1. Save your Power Automate flow. 2. Create a new item in the SharePoint List. Ensure to attach the DOCX template to the item. 3. Verify: * Contract is sent to the employee. * Signature process initiates correctly. * Signed contract saves successfully in SharePoint. * HR receives an email notification with the signed contract attached. *Use the following checklist:* * [ ] Contract sent successfully. * [ ] Employee receives and signs contract. * [ ] Signed document stored correctly in SharePoint. * [ ] HR receives email notification with attachment. ## Troubleshooting & FAQ ### Common Issues: * **API Key Errors:** Ensure your SignatureAPI key is correct and authenticated. * **Dynamic Content Mapping:** Double-check placeholder naming in your DOCX file matches exactly with dynamic content mappings. * **File Access Issues:** Verify permissions and file paths in SharePoint. ### Frequently Asked Questions: * *What if the contract isn't sent?* Check your SignatureAPI dashboard for errors, and verify recipient details. * *Can I adapt this for other document types?* Yes, this method is adaptable for any automated document-signing workflow. * *Can I use columns from the SharePoint List to pre-fill additional template fields?* Yes. Add new columns to your SharePoint List, then reference them as dynamic content when mapping placeholders in the **"Add a Template - DOCX"** action. Just make sure each column name maps to a corresponding `{{placeholder}}` in your DOCX template. ## Best Practices & Security * Always securely manage API keys. * Regularly check flow runs in Power Automate for any errors. * Document any flow or template changes for future reference. ## Additional Resources * [SignatureAPI Documentation](https://signatureapi.com/docs) * [Microsoft SharePoint List Documentation](https://www.microsoft.com/en-us/microsoft-365/microsoft-lists) * [Power Automate Community](https://powerusers.microsoft.com/t5/Microsoft-Power-Automate/ct-p/MPACommunity) ## Conclusion By completing this tutorial, you've successfully automated the process of sending, signing, and managing employment contracts. This efficient workflow frees your HR team from repetitive tasks and ensures new employees have a smooth onboarding experience. **Happy Automating!** # Filter Triggers by Envelope Topic Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/filter-triggers Limit Power Automate flow triggers to specific envelopes using topic filters ## Overview Sometimes you only want to trigger a flow for specific envelopes, not all envelopes in your SignatureAPI account. In this example, we’ll trigger a flow only for envelopes created by the Sales Department. These envelopes use the topic `sales_department`. This guide shows how to filter envelopes that trigger a flow in Power Automate. You’ll learn how to set up a trigger that fires only for envelopes with a specific topic. ## Creating the Envelope This guide assumes you already have a Power Automate flow that creates and starts envelopes using the **"Create an envelope"** action from the SignatureAPI connector. Make sure that flow includes a topic in the **"Envelope Topics"** field under Advanced parameters. In this case, use the topic `sales_department`. Envelope topics ## Trigger a Flow for Selected Envelopes Let’s create an automated flow in Power Automate that starts when a deliverable is generated. 1. Go to **Power Automate** and select **Automated Cloud Flow**. 2. Name your flow and choose the trigger **"When a deliverable is generated"** from the SignatureAPI connector. Trigger 3. In the **"Topics"** field of the trigger, enter `sales_department`. This filters the trigger to only fire for envelopes with this topic. This works like a labeling system. Only envelopes tagged with a matching topic will trigger the flow. This let you route envelopes to different flows based on their topics. Filter ## Continue the Flow Now add the actions that follow the trigger. 1. Add the **"Get a Deliverable"** action. 2. Use dynamic content to select the correct **Deliverable ID** from the trigger. Get deliverable Next, send an email to the correct department. 1. Add the **"Send an email"** action from the Microsoft Outlook connector. 2. In the **"To"** field, enter the department’s email address. 3. Attach the signed contract file using the **"File Content"** from the **"Get a Deliverable"** action. In this example we used the envelope ID as the file name, but you can use anything you want, just include the `.pdf` extension. Send email ## Result This flow will run only when a deliverable is generated for envelopes with the topic `sales_department`. It will get the signed document as a PDF file and send it by email to the correct department. ## Test Your Automation Test the full workflow: 1. Save your Power Automate flow. 2. Create a new envelope with the topic `sales_department`. 3. Sign the document. 4. Check that the correct email is received with the signed PDF attached. ## Keep Learning * Learn more about [Topics and Filters](/docs/integrations/power-automate/envelopes/topics) * Read about the [When the deliverable is generated](/docs/integrations/power-automate/triggers/deliverable-generated) trigger # Notify Your Team of Bounced Emails in Power Automate Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/handle-errors Set up alerts when signing request emails bounce to prevent onboarding delays ## Overview Sometimes emails sent for signature don't reach the recipient. A common issue is a bounced email address. When this happens, HR teams may not notice right away, which can delay onboarding or other processes. This guide shows how to use Microsoft Power Automate and SignatureAPI to detect email bounces when sending signature requests, and automatically send a Slack message to your team. Bounced emails are one of the most common issues in the signing process. You can use this guide as a starting point to handle other problems too. Check the [available triggers](/docs/integrations/power-automate/triggers) for more options. ## Creating the Envelope This guide assumes you already have a Power Automate flow that sends envelopes using the **"Create an envelope"** action from the SignatureAPI connector. You don’t need to change anything in how the envelope is created. The automation starts when the email to the recipient bounces. If you want to only trigger this flow for some envelopes (not all in your account), learn [how to filter triggers](/docs/integrations/power-automate/guides/how-to/filter-triggers) ## Trigger the Flow When an Email Bounces Let’s create a new automated flow that starts when a recipient’s email bounces. 1. Go to **Power Automate** and select **Automated Cloud Flow**. 2. Name your flow and choose the trigger **"When a recipient bounces"** from the SignatureAPI connector. Trigger This trigger will monitor for email bounce events and start the flow when they occur. ## Send a Slack Notification Next, add a step to notify your team in Slack when the trigger runs. 1. Add the **"Post message"** action from the Slack connector. 2. Sign in with your Slack account if prompted. Post to Slack Authorize Slack 3. Choose the Slack **channel** where you want to send the notification. 4. Write a **message** using Dynamic Content from the trigger. For example, include the recipient email and bounce reason. Set Slack Message This step ensures your team is immediately informed when a signature request fails. ## Result Now your flow will: * Detect when a recipient email bounces. * Send a Slack message with the bounce details. This helps your team follow up quickly and avoid delays in signing documents. ## Test Your Automation Test the flow to make sure it works: 1. Save the Power Automate flow. 2. Create a new envelope using a test email address that will bounce. 3. Check the Slack channel for the message. ## Keep Learning * Learn about the [recipient lifecycle](/docs/integrations/power-automate/recipients/recipient#lifecycle) * See the reference for the [When a recipient bounces](/docs/integrations/power-automate/triggers/recipient-bounced) trigger * Explore other [available triggers](/docs/integrations/power-automate/triggers) # Filter SignatureAPI Webhook Notifications Using Microsoft Power Automate Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/how-to-filter-webhooks-notifications Route webhook notifications to specific departments by filtering on envelope topics in Power Automate ## Overview This tutorial shows you how to filter SignatureAPI webhook notifications in Microsoft Power Automate so that only the right department receives alerts for relevant signing events. By using envelope topics as labels, you can route completed documents (such as signed contracts or financial agreements) to the correct team automatically, without writing custom code or building complex conditional logic. ### What You'll Learn * How to configure a SignatureAPI trigger in Power Automate to listen for specific events. * How envelope topics work as a labeling system for routing notifications. * How to filter webhook notifications so only matching envelopes trigger your flow. * How to retrieve a signed deliverable from SignatureAPI. * How to send a targeted email notification with the signed document attached. * How to test and verify the end-to-end filtering workflow. ### The Problem Organizations that process many signature requests often face challenges when all webhook notifications flow into a single channel. Common pain points include: * **Notification overload** - every department receives alerts for every completed envelope, creating noise and causing important documents to get buried. * **Manual sorting** - team members spend time reviewing notifications to determine which ones are relevant to their department. * **Delayed responses** - when the right people are not notified promptly, follow-up actions (filing, countersigning, client communication) are delayed. ### How Automation Helps Automation simplifies notification routing by: * Filtering webhook events at the trigger level using envelope topics, so irrelevant envelopes never start the flow. * Delivering signed documents directly to the responsible department's inbox without manual intervention. * Eliminating the need for shared inboxes or manual forwarding between teams. * Scaling effortlessly as you add new departments or document types, since each topic can have its own dedicated flow. ## Requirements Before starting, make sure you have: * **Power Automate** - To build the automated workflow. * **SignatureAPI account** - For electronic signatures and webhook triggers. * **Microsoft Outlook account** - To send email notifications to the target department. This tutorial also assumes you have an existing Power Automate flow (or another process) that creates and starts envelopes with SignatureAPI. That flow must include a topic in the envelope body using the **Envelope Topics** field under Advanced parameters. In this example, the topic is `sales-department`. Envelope topics configuration showing "sales-department" as the topic value **Important:** Topics act as labels on envelopes. When you assign a topic during envelope creation, you can later use that same topic in a trigger to ensure only matching envelopes activate your flow. ## Flow Overview The automation process follows these steps: 1. **Trigger:** A SignatureAPI webhook fires when a deliverable is generated (a signed document becomes available). 2. **Filter:** The trigger's topic filter ensures the flow only runs for envelopes tagged with the matching topic (for example, `sales-department`). 3. **Retrieve:** The flow fetches the signed deliverable from SignatureAPI. 4. **Notify:** An email with the signed document attached is sent to the designated department. Here's what your final Power Automate flow will look like: Complete Power Automate flow showing the trigger, get deliverable action, and send email action ## Step-by-Step Tutorial Follow these steps to build a Power Automate flow that filters SignatureAPI webhook notifications by topic and sends targeted email alerts to the appropriate department. ### Step 1: Create the Flow and Configure the Trigger Start by creating a new automated flow with a SignatureAPI trigger that listens for deliverable generation events. #### 1.1 Create the Flow 1. Go to **Power Automate** and select **Automated Cloud Flow**. 2. Give your flow a descriptive name (for example, "Sales Department - Signed Document Notification"). 3. Choose the trigger **When a deliverable is generated** from the SignatureAPI connector. SignatureAPI trigger selection showing "When a deliverable is generated" #### 1.2 Add a Topic Filter to the Trigger The topic filter is what makes this flow department-specific. By setting a topic on the trigger, you ensure that only envelopes created with the same topic will activate this flow. 1. In the trigger configuration, locate the **Topics** field. 2. Enter the topic value that matches the one used during envelope creation. In this example, enter `sales-department`. This means the trigger will only fire when a deliverable is generated for an envelope that was created with the `sales-department` topic. Envelopes with different topics (or no topic at all) will not activate this flow. Trigger configuration with "sales-department" entered in the Topics field **Important:** The topic value in the trigger must exactly match the topic assigned to the envelope during creation. Topics are case-sensitive, so `sales-department` and `Sales-Department` are treated as different values. ### Step 2: Retrieve the Signed Document Once the trigger fires, you need to fetch the actual signed document so you can attach it to the notification email. 1. Add a new action and select **Get a Deliverable** from the SignatureAPI connector. 2. In the **Deliverable ID** field, use dynamic content to select the deliverable ID provided by the trigger. This action downloads the signed PDF so it can be used in subsequent steps. Get a Deliverable action with Deliverable ID populated from dynamic content ### Step 3: Send the Email Notification Now configure the email that will deliver the signed document to the target department. 1. Add the action **Send an email (V2)** from the Microsoft Outlook connector. 2. In the **To** field, enter the email address of the department or team that should receive the notification (for example, `sales-team@yourcompany.com`). 3. Fill in the **Subject** and **Body** fields with a clear message indicating a signed document is ready for review. 4. In the **Attachments** section, use dynamic content to attach the file: * Set **Attachments Name** to a descriptive filename ending in `.pdf` (for example, `signed-contract.pdf`). * Set **Attachments Content** to the **File Content** value from the **Get a Deliverable** action. Send an email action configured with recipient, subject, body, and the signed document attached ### Step 4: Test Your Automation With the flow saved, run an end-to-end test to confirm everything works correctly. 1. Save your Power Automate flow and make sure it is turned on. 2. Using your envelope creation flow (or the SignatureAPI dashboard), create a new envelope with the topic `sales-department`. 3. Complete the signing process for that envelope. 4. Verify the following: * The flow run appears in Power Automate's run history with a **Succeeded** status. * The target department receives an email with the signed PDF attached. * Envelopes created without the `sales-department` topic do **not** trigger this flow. *Use the following checklist:* * [ ] Flow run shows as **Succeeded** in Power Automate. * [ ] Email notification arrives at the correct department inbox. * [ ] The signed PDF is attached and can be opened. * [ ] Envelopes with different (or no) topics do not trigger the flow. ## Troubleshooting & FAQ ### Common Issues: * **Flow does not trigger:** Confirm that the topic on the envelope matches the topic in the trigger exactly, including case sensitivity. Also verify that the SignatureAPI connection in Power Automate is authenticated and active. * **API key or connection errors:** Open the SignatureAPI connection in Power Automate and re-authenticate if needed. Make sure you are using a valid API key for the correct environment (test or live). * **Email not received:** Check the recipient address for typos, review the Outlook connector's run output for errors, and look in the recipient's spam or junk folder. ### Frequently Asked Questions: * **Can I filter by multiple topics in a single flow?** Each trigger supports one topic value. If you need to route notifications for multiple topics into the same flow, create a trigger for each topic or use a condition action after the trigger to check the topic value. * **How do I set up filtering for additional departments?** Duplicate this flow and change the topic in the trigger to match the new department's topic (for example, `legal-department` or `hr-department`). Then update the recipient email address accordingly. * **Can I send notifications to Slack or Teams instead of email?** Yes. Replace the Outlook **Send an email** action with a Slack or Microsoft Teams action. The rest of the flow (trigger, topic filter, and deliverable retrieval) remains the same. ## Best Practices & Security * Store your SignatureAPI API key securely using Power Automate's connection management. Never hard-code keys directly in flow expressions. * Monitor your flow runs regularly in Power Automate to catch failures early, especially after making changes to envelope topics or connector settings. * Document each department's topic value and corresponding flow in a shared location so your team can onboard new departments or update routing without confusion. ## Additional Resources * [SignatureAPI Documentation](https://signatureapi.com/docs) * [Microsoft Outlook Documentation](https://support.microsoft.com/outlook) * [Power Automate Community](https://powerusers.microsoft.com/t5/Microsoft-Power-Automate/ct-p/MPACommunity) ## Conclusion You have successfully built a Power Automate flow that filters SignatureAPI webhook notifications by envelope topic and routes signed documents to the appropriate department via email. This approach keeps each team focused on the documents that matter to them, without manual sorting or shared inboxes. **Happy Automating!** # Handle Recipient Bounce Errors with Slack Notifications Using SignatureAPI and Power Automate Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/how-to-handle-errors Detect recipient email bounces in SignatureAPI and send instant Slack notifications using Microsoft Power Automate ## Overview When you send documents for electronic signature through SignatureAPI, delivery failures can occur if a recipient's email address is invalid or unreachable. This tutorial walks you through building a Power Automate flow that automatically detects recipient bounce events from SignatureAPI and sends a notification to a designated Slack channel. By the end, your team will be alerted within seconds of a bounce, allowing you to correct the issue and resend the envelope without delay. ### What You'll Learn * How to create an automated flow triggered by a SignatureAPI recipient bounce event. * How to set up a Slack channel dedicated to error notifications. * How to configure the Slack connector in Power Automate to post messages. * How to use dynamic content from the SignatureAPI trigger to build informative notifications. * How to test your flow end-to-end with a simulated bounce. * How to extend this pattern to other SignatureAPI event triggers. ### The Problem In HR departments and other teams that rely on electronic signatures, it is common to send employment contracts, policy acknowledgements, tax forms, and other critical documents for signing. However, delivery issues can disrupt the process: * **Invalid email addresses** - A typo in the recipient's email or an outdated address causes the delivery to bounce, and the signer never receives the document. * **Delayed awareness** - Without real-time monitoring, teams may not discover a bounce for hours or even days, stalling onboarding, compliance deadlines, or business transactions. * **Manual follow-up burden** - Tracking down bounced envelopes, identifying the correct email, and resending documents manually takes time and introduces the risk of further errors. For example, when a new hire does not receive their employment contract because their email bounced, the entire onboarding process can stall. Both the HR manager and the employee remain unaware of the issue until someone manually checks the envelope status, which could be days later. ### How Automation Helps By connecting SignatureAPI to Slack through Power Automate, you can eliminate these gaps: * **Instant detection** - The flow triggers automatically the moment a recipient bounce occurs, with no polling or manual checks required. * **Real-time team notifications** - A Slack message is posted immediately, ensuring the right people know about the problem within seconds. * **Actionable context** - The notification includes envelope and recipient details from SignatureAPI dynamic content, so your team can take corrective action right away. * **Reduced manual overhead** - No more checking envelope statuses one by one or relying on someone to remember to follow up. ## Requirements Before starting, make sure you have: * **Power Automate** - To build the automated workflow. A Premium license is required for the SignatureAPI connector. * **SignatureAPI account** - For sending documents and receiving event triggers. You will need your API key. * **Slack account** - For receiving bounce notifications. You need permission to create channels and install apps. ## Flow Overview The automation process follows these steps: 1. **Trigger:** A SignatureAPI "When a recipient bounces" event fires when an envelope delivery fails. 2. **Notify Slack:** Power Automate posts a message to your designated Slack channel with the bounce details. Here's what your final Power Automate flow will look like: Complete Flow ## Step-by-Step Tutorial Follow these steps to build a Power Automate flow that sends Slack notifications whenever a SignatureAPI recipient bounce occurs. ### Step 1: Create the Slack Channel Start by creating a dedicated Slack channel where bounce notifications will be posted. Using a dedicated channel keeps error alerts organized and easy to monitor. 1. Open **Slack** and click **"Create Channel"** from the sidebar. Create Slack Channel 2. Name the channel something descriptive (for example, `bounced-emails` or `signature-errors`). Choose whether the channel should be public or private based on your team's needs, then click **"Create"**. Name Slack Channel ### Step 2: Set Up the Power Automate Flow Now create the automated workflow in Power Automate that listens for bounce events and posts to Slack. #### 2.1 Configure the Trigger 1. Go to **Power Automate** and select **"Create"**, then choose **"Automated Cloud Flow"**. 2. Search for and select the trigger **"When a recipient bounces"** from the SignatureAPI connector. If this is your first time using the SignatureAPI connector, you will be prompted to enter your API key to authenticate. Trigger Configuration #### 2.2 Send the Notification to Slack With the trigger in place, add the action that posts a message to your Slack channel. 1. Click **"New step"** and search for the **"Post message"** action from the Slack connector. If you have not connected Slack to Power Automate before, you will be prompted to authorize the connection with your Slack account. Post Message Action Authorize Slack 2. In the **Channel Name** field, select the Slack channel you created in Step 1 (for example, `bounced-emails`). 3. In the **Message Text** field, compose a notification message using **Dynamic Content** from the SignatureAPI trigger. You can include properties such as the envelope title, recipient name, and recipient email address to give your team the context they need to act quickly. Set Message Content ### Step 3: Test Your Automation With the flow built, verify that everything works correctly by simulating a bounce. 1. Save your Power Automate flow and confirm it is turned on. 2. In SignatureAPI, create a new envelope with a recipient email address that will bounce (for example, an invalid or nonexistent address). 3. Wait for the bounce event to fire and check your Slack channel for the notification. 4. Verify the notification contains the correct envelope and recipient details. *Use the following checklist:* * [ ] Power Automate flow is saved and enabled. * [ ] Test envelope is created with an invalid recipient email. * [ ] Slack notification appears in the correct channel. * [ ] Notification message includes the expected envelope and recipient details. ## Troubleshooting & FAQ ### Common Issues: * **SignatureAPI connection errors:** Verify that your API key is entered correctly in the Power Automate connector settings. If the key was recently regenerated, update it in the connection configuration. * **Slack notifications not arriving:** Confirm that the correct channel is selected in the **Post message** action and that the Slack authorization is still valid. You can check the connection status under **Data > Connections** in Power Automate. * **Flow not triggering:** Make sure the flow is turned on and that the envelope you created for testing actually results in a bounce. Check the flow run history in Power Automate for any error details. ### Frequently Asked Questions: * **Can I use this pattern for other SignatureAPI events?** Yes. The SignatureAPI connector offers several event triggers (such as envelope completion, recipient signing, and others). You can replace the bounce trigger with any other available trigger and follow the same steps to send Slack notifications. * **Can I notify a different channel or multiple channels?** You can add multiple **Post message** actions in the same flow, each targeting a different Slack channel. Alternatively, you can use conditional logic to route notifications to different channels based on envelope properties. * **What if I want to use Microsoft Teams instead of Slack?** Replace the Slack **Post message** action with the Microsoft Teams **Post message in a chat or channel** action. The rest of the flow remains the same. ## Best Practices & Security * Store your SignatureAPI API key securely and avoid hardcoding it in flow expressions. Use the built-in connector authentication to manage credentials. * Review your flow run history in Power Automate on a regular basis to catch any failures or unexpected behavior early. * Document your flow configuration and any changes you make so that other team members can maintain or update the automation in the future. ## Additional Resources * [SignatureAPI Documentation](https://signatureapi.com/docs) * [Slack Help Center](https://slack.com/help) * [Power Automate Community](https://powerusers.microsoft.com/t5/Microsoft-Power-Automate/ct-p/MPACommunity) ## Conclusion You have successfully built a Power Automate flow that detects SignatureAPI recipient bounce errors and sends instant Slack notifications to your team. This automation eliminates the risk of unnoticed delivery failures and keeps your document signing workflows running smoothly. **Happy Automating!** # Save Signed Documents to SharePoint and Notify via Outlook with SignatureAPI and Power Automate Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/how-to-save-deliverables-sharepoint Automatically save signed documents to SharePoint and send email notifications using SignatureAPI and Microsoft Power Automate ## Overview This tutorial shows you how to automatically save signed documents to SharePoint and send email notifications using SignatureAPI and Microsoft Power Automate. When a document is signed through SignatureAPI, your flow will retrieve the completed deliverable, store it in the correct SharePoint folder, and notify the responsible team by email through Outlook. This tutorial targets SharePoint Online, but you can adapt the same approach for OneDrive, Azure Blob Storage, or other file storage services. ### What You'll Learn * How to trigger a Power Automate flow using a SignatureAPI webhook event. * How to retrieve a signed deliverable from SignatureAPI using dynamic content. * How to save the signed document to a specific SharePoint Online folder. * How to send an email notification with the signed document attached using the Outlook connector. * How to test and verify the complete end-to-end workflow. ### The Problem In HR departments, it is common to send important documents (employment contracts, policy acknowledgements, tax forms) for electronic signature. However, manual handling of signed documents introduces several challenges: * **Delayed awareness** - there is no immediate way to know when a document has been completed, which slows down follow-up actions. * **Misfiled documents** - signed documents are not always saved in the correct SharePoint folder, making them difficult to locate later. * **Compliance gaps** - when these issues go unnoticed, HR teams face delays in onboarding, auditing, and regulatory compliance processes. ### How Automation Helps Automation helps HR teams stay on top of signed documents by: * Monitoring signature completion status in real time through SignatureAPI webhooks. * Automatically saving the signed document to the correct SharePoint folder as soon as it is available. * Instantly notifying the responsible team via email through Outlook when the document is completed and filed. * Reducing manual follow-ups and eliminating delays in onboarding or compliance workflows. ## Requirements Before starting, make sure you have: * **Power Automate** - To build the automated workflow. * **SignatureAPI account** - For electronic signatures and webhook triggers. * **SharePoint Online** - To store the signed documents in a designated folder. * **Microsoft Outlook account** - To send email notifications to the target department. ## Flow Overview The automation process follows these steps: 1. **Trigger:** A SignatureAPI webhook fires when a deliverable is generated (a signed document becomes available). 2. **Retrieve:** The flow fetches the signed deliverable from SignatureAPI. 3. **Save to SharePoint:** The signed document is saved to the designated SharePoint folder. 4. **Notify:** An email notification with the document details is sent to the responsible team through Outlook. Here's what your final Power Automate flow will look like: Complete Power Automate flow for saving deliverables to SharePoint and sending email notifications ## Step-by-Step Tutorial Follow these steps to build the automation that saves signed documents to SharePoint and notifies your team via Outlook. ### Step 1: Set Up the Power Automate Flow Create the automated workflow in Power Automate, triggered by a SignatureAPI event. #### 1.1 Configure the Trigger Set the flow trigger to fire when SignatureAPI generates a deliverable (the signed document). 1. Go to **Power Automate** and select **Automated Cloud Flow**. 2. Name your flow (for example, "Save Signed Docs to SharePoint"). 3. Choose the trigger **"When a deliverable is generated"** from the SignatureAPI connector. Trigger configuration showing the SignatureAPI "When a deliverable is generated" trigger #### 1.2 Retrieve the Signed Document Add an action to retrieve the completed document from SignatureAPI. 1. Add the **"Get a Deliverable"** action from the SignatureAPI connector. 2. In the **Deliverable ID** field, select the deliverable ID from the trigger's dynamic content. Get a Deliverable action with Deliverable ID mapped from dynamic content #### 1.3 Save the Signed Document to SharePoint Save the signed document to your designated SharePoint folder for record-keeping. 1. Add the **"Create File"** action from the SharePoint connector. 2. Select the **Site Address** for your SharePoint site. 3. Set the **Folder Path** to the location where signed documents should be stored. 4. Set the **File Name** using dynamic content (make sure it ends in `.pdf`). 5. Map the **File Content** field to the file content from the **"Get a Deliverable"** action. Create File action in SharePoint with Site Address, Folder Path, File Name, and File Content configured #### 1.4 Send an Email Notification Send an email notification to the responsible department so they know the signed document has been saved. 1. Add the **"Send an email (V2)"** action from the Microsoft Outlook connector. 2. In the **To** field, enter the email address of the department or team that should receive the notification. 3. Set a descriptive **Subject** line (for example, "Signed Document Ready: \[document name]"). 4. In the **Body**, include relevant details such as the document name and SharePoint location. 5. Optionally, attach the signed document by using the **File Content** from the **"Get a Deliverable"** action and setting the filename (ending in `.pdf`). Send an email action configured with recipient, subject, body, and signed document attachment ### Step 2: Test Your Automation Test the entire process end-to-end to confirm everything works correctly. 1. Save your Power Automate flow. 2. Create a new envelope in SignatureAPI and start the signing process. 3. Sign the document to trigger the deliverable generation event. 4. Verify the following: * The signed document appears in the correct SharePoint folder. * The email notification is received by the designated department. * The email contains the correct document details and attachment. *Use the following checklist:* * [ ] Signed document is saved in the correct SharePoint folder. * [ ] Email notification is received by the designated department. * [ ] Attachment in the email matches the signed document. ## Troubleshooting & FAQ ### Common Issues: * **API Key Errors:** Ensure your SignatureAPI key is correct and properly authenticated in the Power Automate connector. If you recently rotated your key, update it in the connector settings. * **SharePoint Permissions:** Verify that the Power Automate connection has write access to the target SharePoint site and folder. If the **"Create File"** action fails, check the site permissions for the connected account. * **Email Not Received:** Confirm that the email address in the **To** field of the Outlook action is correct. Also check the recipient's spam or junk folder, and verify that the Outlook connector is properly authenticated. ### Frequently Asked Questions: * **What if the email notification is not received?** Check that the Outlook connector is authenticated and that the recipient email address is correct. Review the flow run history in Power Automate to see if the **"Send an email"** action completed successfully or returned an error. * **Can I save deliverables to OneDrive instead of SharePoint?** Yes. Replace the SharePoint **"Create File"** action with the equivalent OneDrive **"Create File"** action. The rest of the flow remains the same. * **Can I notify multiple departments?** Yes. You can add multiple **"Send an email"** actions with different recipients, or use a distribution list in the **To** field to reach several people at once. ## Best Practices & Security * Always store API keys securely and avoid hardcoding them in flow expressions. Use Power Automate's built-in connection management. * Regularly review flow run history in Power Automate to catch and resolve errors early. * Document any changes to your flow or SharePoint folder structure so your team can maintain the automation over time. ## Additional Resources * [SignatureAPI Documentation](https://signatureapi.com/docs) * [SharePoint Documentation](https://support.microsoft.com/sharepoint) * [Microsoft Outlook Connector Reference](https://learn.microsoft.com/en-us/connectors/office365/) * [Power Automate Community](https://powerusers.microsoft.com/t5/Microsoft-Power-Automate/ct-p/MPACommunity) ## Conclusion By completing this tutorial, you have automated the process of saving signed documents to SharePoint and sending email notifications through Outlook with SignatureAPI and Microsoft Power Automate. This workflow frees your HR team from manual follow-ups and ensures signed documents are filed correctly without delay. **Happy Automating!** # How to Use Fixed Positions in SignatureAPI with Microsoft Power Automate Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/how-to-use-fixed-positions Automate document signing with fixed position places using SignatureAPI and Microsoft Power Automate ## Overview This tutorial demonstrates how to streamline the employment contract process by automatically sending, signing, and storing contracts using fixed positions for places. By integrating **Microsoft Forms** (for data collection), **OneDrive** (for storing PDF forms), and the **SignatureAPI connector** (for electronic signatures), you can eliminate manual errors and delays in onboarding new employees. For this tutorial, you will use the W-11 form from the US Internal Revenue Service (IRS), which collects information from taxpayers as part of the Hiring Incentives to Restore Employment (HIRE) Act Employee Affidavit. This approach works for any PDF form with fields that need to be filled at fixed positions. ### What You'll Learn * How to trigger a flow with a new Microsoft Forms response. * How to determine fixed position coordinates for places on a PDF form. * Creating and sending a signature envelope using SignatureAPI with fixed positions for places. * Monitoring the signing process and retrieving the signed document. * Saving the signed contract and notifying HR automatically. ### The Problem HR departments often struggle with manually handling contracts, causing delays in onboarding. Some of these contracts have fixed positions for places that need to be filled. That is the case with the W-11 form. * **Slow processing** - manual tasks create delays. * **Errors** - mistakes from manual data entry. * **Tracking difficulty** - challenges in monitoring signing status. ### How Automation Helps Automation simplifies this process by: * Automatically sending contracts upon form submission. * Using fixed positions for places that need to be filled. * Tracking signature status and storing documents automatically. * Informing HR instantly once contracts are signed. ## Requirements Before starting, make sure you have: * **Power Automate** - To build workflows. * **SignatureAPI account** - For electronic signatures. * **Microsoft Forms** - For collecting employee information. * **OneDrive** - For storing your PDF forms. * **Outlook** - For sending notifications (other email providers also work). This flow also assumes that you have the W-11 PDF form template in your OneDrive, and that you have all the coordinates for the places that need to be filled. ## Flow Overview The automation process follows these steps: 1. **Trigger:** Microsoft Forms submission starts the flow. 2. **Data Retrieval:** Get employee details and fetch the W-11 PDF form template from OneDrive. 3. **Signature Process:** Create an envelope via SignatureAPI, add recipient details, and attach the W-11 PDF form. 4. **Add Fixed Positions:** Add the places with the fixed positions to the W-11 PDF form. 5. **Monitoring:** Wait for the W-11 PDF form to be signed. 6. **Storage & Notification:** Save the signed W-11 PDF form in OneDrive and notify HR via email. Here is what your final Power Automate flow will look like: Flow Flow ## Step-by-Step Tutorial Follow these steps to automate your employment contract process using Microsoft Forms, SignatureAPI, and Power Automate: ### Step 1: Get the Fixed Position Coordinates First, determine the coordinates for each place on your PDF form where data needs to be filled in or signed. You can use a PDF coordinate tool or measure coordinates manually to find the exact positions. **To prepare your PDF form:** 1. Get the coordinates of the places that need to be filled. You can use a PDF coordinate tool or measure coordinates manually to determine the `top` and `left` values for each place. 2. Flatten the form to a single-page PDF if needed. 3. Upload it to **OneDrive** (or another preferred storage service). The fixed positions for the W-11 form are going to be the following: ```json theme={null} [ { "page": 1, "top": 154.0, "left": 86.4, "place_key": "employee_name" }, { "page": 1, "top": 154.0, "left": 482.4, "place_key": "security_number" }, { "page": 1, "top": 178.0, "left": 158.4, "place_key": "first_date_employment_0" }, { "page": 1, "top": 178.0, "left": 194.4, "place_key": "first_date_employment_1" }, { "page": 1, "top": 178.0, "left": 230.4, "place_key": "first_date_employment_2" }, { "page": 1, "top": 178.0, "left": 345.6, "place_key": "employer_name" }, { "page": 1, "top": 235, "left": 113, "place_key": "employee_signature" }, { "page": 1, "top": 235, "left": 476, "place_key": "employee_completed_date" } ] ``` **Important:** The `top` and `left` coordinates are in points and are relative to the top-left corner of the page. The `top` value is the distance from the bottom of each place to the top of the page. W-11 Form ### Step 2: Create the Microsoft Form Create a Microsoft Form to collect the necessary employee details (First Name, Last Name, Email Address). 1. Visit [Microsoft Forms](https://forms.office.com) and sign in. 2. Click **New Form**. New Form 3. Name the form and add these required questions: * **First Name** (Text, required) * **Last Name** (Text, required) * **Email Address** (Text, required) Add request Rename form 4. Save and publish your form. Employee Form ### Step 3: Set Up the Power Automate Flow Now, create the automated workflow in Power Automate, triggered whenever a form is submitted. #### 3.1 Configure the Trigger Set the flow trigger to run whenever your form is submitted. 1. Go to **Power Automate** and select **Automated Cloud Flow**. 2. Choose the trigger **When a new response is submitted** (Microsoft Forms). Trigger 3. Select the form you created earlier. Select form #### 3.2 Retrieve Employee Details Next, retrieve the employee details submitted through the form. 1. Add the action **Get response details**. 2. Select your form (**Form ID**) and the response (**Response ID**) from Dynamic Content. Get response details #### 3.3 Retrieve the PDF Form from OneDrive Fetch your PDF form template stored in OneDrive. 1. Add **Get File Content using Path** from the OneDrive connector. 2. Select the PDF template stored in your OneDrive. Get file content ### Step 4: Set Up the Signature Process In this step, you will configure SignatureAPI to create, send, and track the signature process. #### 4.1 Create a SignatureAPI Envelope Begin by creating an envelope to hold your document and signature process. 1. Add the **Create an Envelope** action (SignatureAPI connector). 2. If prompted, authenticate your connection using your SignatureAPI key from the [SignatureAPI Dashboard](https://dashboard.signatureapi.com/settings/api-keys). 3. Set an **Envelope Title** (for example, employee name) and email message using dynamic content. 4. From the advanced section, set the **Envelope Routing** to `sequential`. Create envelope #### 4.2 Add the Recipient Next, specify who will receive and sign the document. 1. Add the **Add Recipient** action. 2. Map **Recipient Name** and **Recipient Email** using form details (Dynamic Content). 3. Set the **Recipient Key** (for example, `employee`), matching your place keys. Add recipient #### 4.3 Attach the W-11 PDF Form Now, attach your PDF form to the envelope. 1. Add the **Add a document - PDF** action. 2. Select **File Content** from the OneDrive action. 3. Set the **Document Title** (for example, "W-11 Form"). Add template ### Step 5: Add the Fixed Positions to the W-11 Form #### 5.1 Define Signature Placement Specify where the employee should sign on the document. 1. Add the **Add a place - Signature** action. 2. Set the **Place Key** to `employee_signature`. 3. Set the **Recipient Key** using dynamic content. 4. Set the **Document ID** using dynamic content. 5. From the advanced section, set the **Place Height** to `30`. This can be adjusted according to the available space for the signature. See the [Signature Height Docs](https://signatureapi.com/docs/integrations/power-automate/actions/add-place-signature#param-place-height) for more details. 6. From the advanced section, select the **Page Number**, **Distance From Top**, and **Distance From Left** coordinates. Set them to the `employee_signature` place values from the fixed positions. Add signature #### 5.2 Define the Employee Completed Date Place Specify the place for the employee completed date. 1. Add the **Add a place - Recipient completed date** action. 2. Set the **Place Key** to `employee_completed_date`. 3. Set the **Document ID** using dynamic content. 4. Set the **Recipient Key** using dynamic content. 5. From the advanced section, select the **Page Number**, **Distance From Top**, and **Distance From Left** coordinates. Set them to the `employee_completed_date` place values from the fixed positions. Add employee completed date #### 5.3 Define the Text Input Places For all other places that are text inputs, use the **Add a place - Text Input** action. For example, the employee name: 1. Add the **Add a place - Text Input** action and rename it to **Add a place - Text Input - Employee Name**. 2. Set the **Place Key** to `employee_name`. 3. Set the **Document ID** using dynamic content. 4. Set the **Recipient Key** using dynamic content. 5. From the advanced section, select the **Page Number**, **Distance From Top**, and **Distance From Left** coordinates. Set them to the `employee_name` place values from the fixed positions. Add employee name Repeat the same process for the other text input places, using the corresponding fixed position coordinates and place keys. ### Step 6: Start the Signing Process Trigger the sending of your envelope to the employee for signing. 1. Add the **Start Envelope** action. 2. Select the appropriate **Envelope ID** using dynamic content. Start envelope ### Step 7: Monitor and Finalize the Contract Configure your flow to wait for the signing to complete, retrieve the signed contract, and notify HR. #### 7.1 Wait for Signature Completion Pause the flow until the employee signs the contract. 1. Add the **Wait for Envelope Completion** action. 2. Select the correct **Envelope ID** using dynamic content. Wait for envelope completion #### 7.2 Retrieve the Signed Contract Once signed, automatically retrieve the completed document. 1. Add the **Get a Deliverable** action. 2. Select the correct **Deliverable ID** using dynamic content. Get deliverable #### 7.3 Save the Signed Contract to OneDrive Save the signed document for record-keeping. 1. Add the **Create File** action (OneDrive connector). 2. Set the folder path and filename (ending in `.pdf`). 3. Map **File Content** from the deliverable. Save file #### 7.4 Notify HR via Email Automatically inform HR that the contract has been signed and saved. 1. Add the **Send an Email** action (Outlook connector). 2. Configure the email recipient (HR), subject, and message. 3. Attach the signed contract file from dynamic content. Use the **File Content** from the **Get a Deliverable** action, and set the filename to end in `.pdf`. Send email ### Step 8: Test Your Automation Finally, test the entire process end-to-end. 1. Save your Power Automate flow. 2. Submit a test response through your Microsoft Form. 3. Verify the following: * Contract is sent to the employee. * Signature process initiates correctly. * Signed contract saves successfully in OneDrive. * HR receives an email notification with the signed contract attached. Use the following checklist: * [ ] Contract sent successfully. * [ ] Employee receives and signs contract. * [ ] Signed document stored correctly in OneDrive. * [ ] HR receives email notification with attachment. ## Troubleshooting & FAQ ### Common Issues: * **API Key Errors:** Ensure your SignatureAPI key is correct and authenticated. * **Dynamic Content Mapping:** Double-check that place key names match exactly with the fixed position coordinates you defined in Step 1. * **File Access Issues:** Verify permissions and file paths in OneDrive. ### Frequently Asked Questions: * **What if the contract is not sent?** Check your SignatureAPI dashboard for errors and verify recipient details. * **Can I adapt this for other document types?** Yes, this method is adaptable for any PDF form that requires fixed position places. * **How do I find the coordinates for my own PDF?** You can use a PDF coordinate tool or measure coordinates manually. The `top` and `left` values are in points, measured from the top-left corner of the page. ## Best Practices & Security * Always securely manage API keys and avoid hardcoding them in your flows. * Regularly check flow runs in Power Automate for any errors. * Document any flow or template changes for future reference. ## Additional Resources * [SignatureAPI Documentation](https://signatureapi.com/docs) * [Microsoft Forms Help](https://support.microsoft.com/forms) * [Power Automate Community](https://powerusers.microsoft.com/t5/Microsoft-Power-Automate/ct-p/MPACommunity) ## Conclusion By completing this tutorial, you have successfully automated the process of sending, signing, and managing employment contracts using fixed positions. This workflow frees your HR team from repetitive tasks and ensures new employees have a smooth onboarding experience. **Happy Automating!** # Automating Bulk Sales Proposals with Excel, SignatureAPI, and Microsoft Power Automate Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/multiple-envelopes-excel-bulk Send bulk sales proposals for signature using data from Excel spreadsheets with SignatureAPI and Power Automate. ## Overview This tutorial shows you how to automate your sales proposal process by sending, signing, and storing proposals in bulk. By integrating **Microsoft Excel** (for storing proposal data), **OneDrive** (for storing proposal templates), and **SignatureAPI** (for the approval-and-signature workflow), you can eliminate manual errors and delays when sending out proposals. ### What You'll Learn * How to trigger a flow manually and pull data from an Excel file. * How to retrieve and pre-fill a DOCX proposal template from OneDrive. * How to create and send signature envelopes using SignatureAPI. * How to monitor the signing process and retrieve signed documents. * How to save signed proposals and notify the sales team automatically. ### The Problem Sales teams often struggle with manually handling proposals, causing delays and inconsistencies. Common issues include: * **Slow processing** caused by repetitive manual tasks. * **Errors** from manual data entry across multiple proposals. * **Tracking difficulty** when monitoring signing status for many clients at once. ### How Automation Helps Automation simplifies this process by: * Automatically sending proposals to all clients listed in the spreadsheet. * Using templates pre-filled with each client's proposal data. * Tracking signature status and storing documents automatically. * Informing the sales team instantly once proposals are signed. ## Requirements Before starting, make sure you have: * **Power Automate** for building workflows. * **SignatureAPI account** for electronic signatures. * **Microsoft Excel** for storing proposal data. * **OneDrive** for storing the proposal DOCX templates. * **Outlook** for sending notifications (other email providers also work). ## Flow Overview The automation process follows these steps: 1. **Trigger:** Manually trigger the flow. 2. **Data Retrieval:** Get client proposal data from the Excel file. 3. **Signature Process:** Loop through each row to create an envelope via SignatureAPI, add recipient details, and attach the DOCX template. 4. **Monitoring:** Wait for each proposal to be signed. 5. **Storage & Notification:** Save the signed document in OneDrive and notify the sales team via email. This tutorial uses two flows. The first flow creates the envelopes and sends proposals to clients. Flow The second flow monitors the signing process and notifies the sales team. Flow ## Step-by-Step Tutorial Follow these steps to automate your sales proposal process using Microsoft Excel, OneDrive, SignatureAPI, and Microsoft Power Automate. ### Step 1: Prepare the Proposal Template First, create or update your proposal template by adding placeholders for dynamic fields and defining where the client will sign. **To prepare your template:** 1. Open your existing proposal template (DOCX format) in Microsoft Word. 2. Identify each place where proposal data should be dynamically inserted (for example, client name, contact person, email). 3. Insert placeholders using **double curly brackets** around descriptive keys. Examples: * Client name: `{{client.name}}` * Contact name: `{{contact.name}}` * Contact email: `{{contact.email}}` 4. Define the location for the signature by inserting a signature placeholder using **double square brackets**, for example: `[[client_signature]]` **Example placeholder usage in your document:** > *Dear `{{client.name}}`,* > *Please review and sign your proposal below:* > `[[client_signature]]` 5. Save your template. **Important:** * Ensure placeholder keys match exactly with what you will use later in Power Automate. * Keep your template simple and clear to avoid confusion during dynamic insertion. Word Template Example ### Step 2: Create the Excel File Create an Excel file to store the proposal data for all clients. 1. Open Microsoft Excel and create a new blank workbook. Excel Template 2. Add the following columns: * **Client Name** (Text) * **Contact Name** (Text) * **Contact Email** (Text) 3. Convert your sheet into a table so that Power Automate can read the data. To do this: * Select all of the columns and rows. * In the Ribbon, switch to the **Insert** section and select **Table**. Excel Template * You can also name your table by selecting it, clicking **Table Design** in the ribbon, and setting the name. Excel Template 4. Save the Excel file to OneDrive. ### Step 3: Set Up the Power Automate Flow Now, create the automated workflow in Power Automate, triggered manually. #### 3.1 Configure the Trigger First, set the flow trigger to run manually. 1. Go to **Power Automate** and select **Instant Cloud Flow**. 2. Name your flow, select **"Manually trigger a flow"**, and then click **Create**. Trigger #### 3.2 Retrieve Proposal Data from the Excel File Next, retrieve the proposal data from the Excel file. 1. Add the action **"List rows present in a table"** from the Excel connector. 2. Select the **Location** of the Excel file. For **OneDrive for Business**, select the **Document Library** and then select the Excel **File**. 3. Select the **Table Name** from the Excel file. List Rows #### 3.3 Initialize a Variable In this step, you will initialize a variable to store the proposal data. 1. Add the action **"Initialize Variable"** from the Variables connector. 2. Set the **Name** to a variable name (for example, `clientsData`). 3. Set **Type** to `Array`. 4. Set **Value** to the proposal data from the **"List rows present in a table"** action. Initialize Variable #### 3.4 Get File Content 1. Add the **"Get file content using path"** action from the OneDrive for Business connector. 2. Select the file path to the proposal template. Get File Content #### 3.5 Apply to Each Loop Now, add the **"Apply to each"** action so the flow iterates through each row in the Excel table. 1. Add the **"Apply each"** action from the Control connector. 2. Set the **Items** to the proposal data from the **"List rows present in a table"** action using dynamic content. Apply Each ### Step 4: Set Up the Signature Process In this step, you will configure SignatureAPI to create, send, and track the signature process for each proposal. #### 4.1 Create a SignatureAPI Envelope Inside the **"Apply each"** loop, begin by creating an envelope to hold the proposal and manage the signature process. 1. Add the **"Create an Envelope"** action (SignatureAPI connector). 2. If prompted, authenticate your connection using your SignatureAPI key from the [SignatureAPI Dashboard](https://dashboard.signatureapi.com/settings/api-keys). 3. Set an **Envelope Title** (for example, "proposal") and a message using dynamic content. 4. In the advanced options, select **Topics** and set a topic that all envelopes will share (for example, `clients_proposals`). This will be useful later when monitoring the signing process. Create envelope #### 4.2 Add the Recipient Next, specify who will receive and sign the proposal. 1. Add the **"Add Recipient"** action from the SignatureAPI connector. 2. Map **Recipient Name** and **Recipient Email** using dynamic content from the Excel data. 3. Set the **Recipient Key** (for example, `client`), matching your DOCX placeholders. Add recipient #### 4.3 Attach the DOCX Proposal Template Now, attach your proposal template to the envelope and populate it with client details. 1. Add the **"Add a Template - DOCX"** action. 2. Select **File Content** from the OneDrive action. 3. Select the **Envelope ID** from the **"Create an Envelope"** action. 4. Set the **Document Title** (for example, "Client Name Proposal"). 5. Ensure your DOCX template uses placeholders (`{{client.name}}`, etc.) and map each field to the corresponding dynamic content from your Excel data. Add template #### 4.4 Define Signature Placement Specify where the client should sign on the document. 1. Add the **"Add a Place - Signature"** action. 2. Set the **Document ID** using dynamic content. 3. Use the placeholder (for example, `[[client_signature]]`) from your DOCX template. 4. Set the **Recipient Key** using dynamic content. Add signature #### 4.5 Start the Signing Process Trigger the sending of your envelope to the client for signing. 1. Add the **"Start Envelope"** action from the SignatureAPI connector. 2. Select the appropriate **Envelope ID** using dynamic content. 3. Save the flow. Start envelope ### Step 5: Monitor and Finalize the Proposal Next, configure a second flow to wait for signing to complete, retrieve the signed proposal, and notify the sales team. #### 5.1 Create a New Flow to Monitor the Signing Process Create a new **"Automated cloud flow"** to monitor the signing process. 1. Go to **Power Automate** and select **Automated Cloud Flow**. 2. Name your flow, then select **"When a deliverable is generated"** from the SignatureAPI connector. Create flow 3. Select the **Topics** item to filter the deliverables this flow will process. This should be the same topic you defined in **Step 4.1** (for example, `clients_proposals`). Select topic #### 5.2 Retrieve the Signed Proposal Retrieve the signed proposal from SignatureAPI. 1. Add the **"Get a Deliverable"** action from the SignatureAPI connector. 2. Select the correct **Deliverable ID** using dynamic content. Get deliverable #### 5.3 Save the Signed Proposal to OneDrive Save the signed document for record-keeping. 1. Add the **"Create File"** action (OneDrive connector). 2. Set the folder path and filename (ending in `.pdf`). 3. Map **File Content** from the deliverable. Save file #### 5.4 Notify the Sales Team via Email Automatically inform the sales team that the proposal has been signed and saved. 1. Add the **"Send an Email"** action (Outlook connector). 2. Configure the email recipient (sales team), subject, and message. 3. Attach the signed proposal file from dynamic content. * Add the name of the attachment with a `.pdf` extension. * Add the signed proposal file from dynamic content. 4. Save the flow. Send email ### Step 6: Test Your Automation Finally, test the entire process end-to-end. 1. Manually trigger the flow. 2. Verify: * Proposals are sent to all clients listed in the Excel file. * The signature process initiates correctly for each envelope. 3. After the signing process is completed, verify: * Signed proposals save successfully in OneDrive. * The sales team receives an email notification with the signed proposal attached. *Use the following checklist:* * [ ] Proposals sent successfully for all rows in the Excel file. * [ ] Each client receives and signs their proposal. * [ ] Signed proposals are stored correctly in OneDrive. * [ ] Sales team receives email notifications with attachments. ## Troubleshooting & FAQ ### Common Issues * **API Key Errors:** Ensure your SignatureAPI key is correct and authenticated. * **Dynamic Content Mapping:** Double-check that placeholder names in your DOCX file match exactly with the dynamic content mappings in Power Automate. * **File Access Issues:** Verify permissions and file paths in OneDrive. * **Excel Table Not Found:** Make sure you converted the Excel sheet into a named table (see Step 2). Power Automate requires a table to list rows. * **Loop Not Iterating:** If the **"Apply to each"** loop runs only once or not at all, confirm the **"List rows present in a table"** action returns the expected rows. Check that the correct table name is selected. ### Frequently Asked Questions * *What if proposals are not sent for some rows?* Check the flow run history in Power Automate to identify which iteration failed. Common causes include missing or invalid email addresses in the Excel file. * *Can I add more columns to the Excel file?* Yes. You can add columns (for example, company address or proposal amount) and map them to additional placeholders in your DOCX template. * *How many rows can the Excel file have?* Power Automate handles hundreds of rows, but very large files may cause timeout issues. If you have more than 500 rows, consider splitting them across multiple files or runs. * *How do I update the proposal template without breaking the flow?* Keep the same placeholder names in the updated DOCX template. As long as the placeholders match the dynamic content mappings in Power Automate, the flow will continue to work. * *Can I schedule this flow instead of triggering it manually?* Yes. Replace the manual trigger with a **Recurrence** trigger to run the flow on a schedule (for example, daily or weekly). ## Best Practices & Security * Always securely manage API keys. * Regularly check flow runs in Power Automate for any errors. * Document any flow or template changes for future reference. ## Additional Resources * [SignatureAPI Documentation](https://signatureapi.com/docs) * [Microsoft OneDrive Documentation](https://www.microsoft.com/en-us/microsoft-365/onedrive/online-cloud-storage) * [Microsoft Excel Documentation](https://www.microsoft.com/en-us/microsoft-365/excel) * [Power Automate Community](https://powerusers.microsoft.com/t5/Microsoft-Power-Automate/ct-p/MPACommunity) ## Conclusion By completing this tutorial, you have successfully automated the process of sending, signing, and managing bulk sales proposals from an Excel spreadsheet. This workflow frees your sales team from repetitive tasks and ensures every client receives a consistent, professional proposal experience. **Happy Automating!** # Save Signed Documents Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/how-to/save-deliverables Automatically save signed document deliverables to SharePoint or OneDrive ## Overview In SignatureAPI, signed documents are called [Deliverables](/docs/integrations/power-automate/deliverables/deliverable.mdx). A deliverable is generated automatically once all recipients have signed an envelope. You can see [an example here](/docs/integrations/power-automate/deliverables/audit-log). Deliverables are available for download in PDF format. In many cases, you’ll want to save them to a specific folder (such as SharePoint or OneDrive) for compliance, auditing, or internal record-keeping. This guide shows how to use Microsoft Power Automate and SignatureAPI to: * Trigger a flow when a deliverable is generated. * Save the signed PDF to SharePoint. * Send a notification email with the file attached. This example uses SharePoint Online, but the same steps work with OneDrive, Dropbox, Google Drive, or other file storage systems. If you want to only trigger this flow for some envelopes (not all in your account), learn [how to filter triggers](/docs/integrations/power-automate/guides/how-to/filter-triggers) ## Creating the Envelope This guide assumes you already have a flow that sends documents for signature using the **"Create an envelope"** action from the SignatureAPI connector. No changes are needed in the envelope setup. The steps below focus on what happens after the document is signed. ## Trigger the Flow When a Deliverable Is Generated First, create a flow that starts when a deliverable is ready. 1. Go to **Power Automate** and choose **Automated Cloud Flow**. 2. Name your flow and select the trigger **"When a deliverable is generated"** from the SignatureAPI connector. Trigger This trigger runs when a signed document is available for download. ## Save the Deliverable to SharePoint Next, add steps to retrieve the file and store it in SharePoint. 1. Add the **"Get a Deliverable"** action. 2. Use dynamic content to select the **Deliverable ID** from the trigger. Get deliverable 3. Add the **"Create file"** action from the SharePoint connector. 4. Set the **Site Address** and **Folder Path**. 5. Set the **File Name** (use a `.pdf` extension). 6. Use **File Content** from the deliverable. Save file This step saves the signed document in your SharePoint folder. ## Send a Notification Email Now send an email with the signed PDF attached. 1. Add the **"Send an email"** action from the Outlook connector. 2. In the **"To"** field, enter the department’s email address. 3. Attach the deliverable using **File Content** from the **Get a Deliverable** action. 4. Set the filename (make sure to include `.pdf`). Send email This lets the team know the signed document has been saved and is available for review. ## Result This flow will: * Trigger when a deliverable is generated. * Save the signed PDF to SharePoint. * Send a notification email with the file attached. This automation reduces manual work and helps ensure signed documents are stored and shared consistently. ## Test Your Automation Test the full workflow: 1. Save your Power Automate flow. 2. Create and sign a new envelope. 3. Check that the email arrives and the file is saved to SharePoint. ## Keep Learning * Learn more about the [When a deliverable is generated](/docs/integrations/power-automate/triggers/deliverable-generated) trigger * Read the guide on [deliverables](/docs/integrations/power-automate/deliverables/deliverable) * See an example of a [deliverable](/docs/integrations/power-automate/deliverables/audit-log) # Automate Contract Signing with SignatureAPI and Microsoft Power Automate Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/intermediate-tutorial This tutorial shows how to streamline contract signatures by integrating SignatureAPI with Microsoft Forms, Power Automate, OneDrive, Dataverse, and Outlook. ## Overview This tutorial guides you through automating the employment contract process using SignatureAPI integrated with Microsoft tools such as Forms, Power Automate, OneDrive, and Dataverse. You will build an automated workflow that begins when a new employee submits a form. The flow generates a personalized contract, sends it for signing using SignatureAPI, captures any information filled during signing, and stores the results automatically. HR is notified when the process is completed. ### What you'll learn * How to fill a document template with data using SignatureAPI. * How to set up signature and input fields in your document. * How to send documents to multiple signers using SignatureAPI. * How to collect additional information from signers during the signing process. * How to send documents for signature and track their status. * How to retrieve the signed document and save it. ### Tools you'll use * **SignatureAPI** – to generate, send, and manage signing workflows. SignatureAPI handles document generation, signature requests, tracking, and document delivery. Sign up for a free account to get your test API key. Use it to generate non-binding envelopes and test your integration with SignatureAPI. * **Microsoft Power Automate** – to build and automate the workflow. * **Microsoft Forms** – to collect employee information. * **OneDrive** – to store your DOCX template and signed contract (other document repositories also work). * **Microsoft Dataverse** – to store employee data. * **Microsoft Outlook** – to send notifications (other email providers also work). ### Flow overview The flow follows these steps: 1. **Trigger** – A Microsoft Forms submission starts the flow. 2. **Data Retrieval** – Employee details are pulled from the form, and the contract template is fetched from OneDrive. 3. **Signature Process** – An envelope is created in SignatureAPI, recipients are added, and the DOCX template is filled and sent. 4. **Monitoring** – The flow waits until all parties have signed. 5. **Storage & Notification** – The signed contract is saved to OneDrive, employee data is stored in Dataverse, and HR is notified by email. Here’s what your final Power Automate flow will look like: Flow ## Prepare the contract template Begin by preparing your employment contract template in DOCX format. This template is used to generate personalized contracts. You need to add two types of annotations to your document: **template fields** and **placeholders**. **Template Fields** Template fields insert data into the document before it is sent to recipients. These fields are marked with **double curly brackets**, for example: `{{employee.first_name}}`. SignatureAPI replaces these fields with actual values when generating the document. Learn more about [document templates](/docs/integrations/power-automate/documents/templates). **Placeholders** Placeholders mark where recipients should sign or enter information during the signing process. These are identified by **double square brackets**, for example: `[[employee_signature]]`. Learn more about [placeholders](/docs/integrations/power-automate/places/positioning#placeholders). In this tutorial, we will: * Use **template fields** to fill in employee details. * Define signature places for both the employer and the employee using **placeholders**. * Add a text input place for the employer to enter the salary using a **placeholder**. To prepare your template: 1. Open your existing employment contract (DOCX) in Microsoft Word. 2. Locate where employee details should be inserted (e.g., name, email). 3. Add template fields using **double curly brackets**, for example: * First name: `{{employee.first_name}}` * Last name: `{{employee.last_name}}` * Email: `{{employee.email}}` 4. Add placeholders for signatures using **double square brackets**, for example: * Employer signature: `[[employer_signature]]` * Employee signature: `[[employee_signature]]` 5. Add a placeholder for salary input: `[[salary_input]]` 6. Save the template and upload it to **OneDrive** (or another supported storage service). In the example shown below, placeholders and template fields are colored blue for visibility. In your final document, we recommend coloring them white so they are hidden from recipients. Word Template Example ## Create the Microsoft Form We use Microsoft Forms to collect employee details such as name and email address. 1. Visit [Microsoft Forms](https://forms.office.com) and sign in. 2. Click **New Form**. New Form 3. Name your form and add the following required questions: * **First Name** (Text, required) * **Last Name** (Text, required) * **Email Address** (Text, required) Add request Rename form 4. Save and publish your form. Employee Form ## Create the Dataverse table We will store employee details in a Dataverse table. 1. Go to [Power Apps](https://make.powerapps.com) and sign in. 2. In the left menu, click on **"Tables"**. 3. Click **Start with a blank table**. Start with a blank table 4. Add the following columns, all with **Text** format and **Required**: * **First Name** * **Last Name** * **Email Address** * **Salary Amount** * **Signature Completion** Add columns 5. Rename the table: * Click **Properties**, then enter a new name (e.g., **Contracts**). * Change the **Primary column** to **Email Address**. * Click **Save and exit**. Rename table ## Build the Power Automate flow Now that you have the contract template, the form, and the Dataverse table set up, create a Power Automate flow that runs whenever someone submits the form. ### Configure the trigger Set up the flow trigger so it runs when a new form response is submitted. 1. Go to **Power Automate** and select **Automated Cloud Flow**. 2. Choose the trigger **"When a new response is submitted"** from the **Microsoft Forms** connector. 3. Click **Create**. Trigger 3. In the **Form Id** field, select your form from the dropdown. Select form ### Retrieve form response details Get the details submitted by the employee. 1. Add the **Get response details** action from the **Microsoft Forms** connector. 2. In the **Form Id** field, select the same form. 3. In the **Response Id** field, select **Response Id** from the trigger step. Get response details ### Retrieve the contract template from OneDrive Fetch the contract template stored in OneDrive. 1. Add **Get file content using path** from the **OneDrive** connector. 2. In the **File Path** field, select the DOCX template you uploaded. Get file content ### Create an envelope In SignatureAPI, an [Envelope](/docs/integrations/power-automate/envelopes/envelope) is a container that holds one or more documents to be sent to recipients. It defines and manages the signing process for those documents. Start by creating the envelope in your flow: 1. Add the **Create an envelope** action from the **SignatureAPI** connector. 2. If this is your first time using the connector, you’ll be prompted to enter your SignatureAPI API key. Learn more about [authentication and connections](/docs/integrations/power-automate/authentication). 3. Set an **Envelope Title** and include a message to recipients. You can use dynamic data from earlier steps. 4. In **Advanced parameters**, set **Envelope Routing** to **Sequential**. This ensures the employer signs first, followed by the employee. Envelope routing ### Add the employer as a recipient Add the first recipient, the **employer**. 1. Add the **Add a recipient** action from the **SignatureAPI** connector. 2. Rename the action to **Add a recipient – Employer** to keep things organized. 3. Set the **Recipient Name** and **Recipient Email** (e.g., "John Doe" and "[john.doe@example.com](mailto:john.doe@example.com)"). 4. Set the **Recipient Key** field to `employer`. You’ll reference this key when assigning signature places. Add recipient employer ### Add the employee as a recipient Add the second recipient, the **employee**. 1. Add the **Add a recipient** action from the **SignatureAPI** connector. 2. Rename the action to **Add a recipient – Employee**. 3. Set the **Recipient Name** and **Recipient Email** using dynamic content from the **Get response details** step. 4. Set the **Recipient Key** field to `employee`. Add recipient employee ### Add the contract template Next, add your contract template to the envelope and populate it with employee data. 1. Add the **Add a Template – DOCX** action from the **SignatureAPI** connector. 2. In the **File Content** field, select the **File Content** output from the **Get file content using path** action (OneDrive). 3. (Optional) Set a **Document Title**. 4. Use the **Template Data** array to fill in the template fields. For each field, add a **Template Data Item** in `key: value` format. For example, to fill the field `{{employee.first_name}}` with the value "Richard Roe", set the item as `employee.first_name: Richard Roe`. You can use dynamic content from earlier steps to set values for each template field. Add template ### Add a signature place for the employer When preparing the template, you set a placeholder `[[employer_signature]]` to indicate where in the document the employer will sign. Now, add a **Signature place** to the document and associate this placeholder with the employer. Use the placeholder key `employer_signature` to identify the place in the document and the recipient key `employer` to identify the recipient. 1. Add **"Add a place – Signature"** action from the **SignatureAPI** connector. Rename it to **Add a place – Employer Signature** for clarity. 2. Set the **Place Key** field to the placeholder key used inside the document (without square brackets), for example, `employer_signature`. 3. Set the **Recipient Key** field to `employer`, matching the recipient key you set earlier. 4. Set the **Document ID** field to the **Document ID** from the previous **Add a Template – DOCX** action. Add place employer ### Add the salary input for the employer In a similar way, add a **Text Input Place** to link the `[[salary_input]]` placeholder in the document with the employer. To access this value programmatically and add it to the Dataverse table later, capture this value by setting the **Capture As** field (in advanced parameters). Learn more about [captured values](/docs/integrations/power-automate/envelopes/captures). 1. Add an **Add a place – Text Input** action from the **SignatureAPI** connector. Rename it to **Add a place – Salary Input**. 2. Set the **Place Key** field to the placeholder key used inside the document (without the square brackets), for example, `salary_input`. 3. Set the **Recipient Key** field to `employer`, as before. 4. Set the **Document ID** field to the **Document ID** from the previous **Add a Template – DOCX** action. 5. To retrieve the value filled by the employer, set the **Capture As** field to `salary_input`. This allows you to retrieve this value later in the flow. Add place salary ### Add a signature place for the employee As you did for the employer, add a **Signature Place** for the employee. 1. Add **"Add a place – Signature"** action from the **SignatureAPI** connector. Rename it to **Add a place – Employee Signature** for clarity. 2. Set the **Place Key** field to the placeholder key used inside the document (without the square brackets), for example, `employee_signature`. 3. Set the **Recipient Key** field to `employee`, matching the recipient key you set for the employee. 4. Set the **Document ID** field to the **Document ID** from the previous **Add a Template – DOCX** action. Add place employee ### Start the signing process This step indicates the envelope is ready to be sent for signing. At this point, the envelope is fully assembled and sent to recipients. 1. Add **"Start Envelope"** action from the **SignatureAPI** connector. 2. Set the **Envelope ID** field to the **Envelope ID** output of the **Create an Envelope** action. Start envelope ### Wait until all recipients have signed Use the **Wait for envelope** action to pause the flow until all recipients have signed the document. Use **Wait for envelope** only if you expect fewer than 100 pending envelopes at once, and if you expect recipients to sign soon, since Power Automate actions cannot run for more than 30 days. For more flexibility, consider the trigger [When a deliverable is generated](/docs/integrations/power-automate/guides/how-to/save-deliverables) instead. 1. Add **"Wait for envelope"** action from the **SignatureAPI** connector. 2. Set the **Envelope ID** field to the **Envelope ID** output of the **Create an Envelope** action. Wait for envelope completion ### Get the captured salary input At this point in the flow, recipients have signed, the envelope is completed, and the deliverable (the signed document) is generated. You can now retrieve the captured value from the salary input field the employer filled during the signing ceremony. 1. Add **Get a captured value** action from the **SignatureAPI** connector. 2. Set the **Envelope ID** field to the **Envelope ID** output of the **Create an Envelope** action. 3. In the **Capture Key** field, set the same key you used in the **Add a place – Text Input** action (in this case `salary_input`). Get captured value ### Add a row to the Dataverse table Now, add a row to the Dataverse table using the employee details and the captured salary amount. 1. Add **Add a new row** action from the **Micorosft Dataverse** connector. 2. In the **Table name**, select the table you created earlier (for example, **Employee Contracts**). 3. From the **Advanced parameters**, select the **Fields** to map to the employee details and the captured salary amount using dynamic content: * Set the **First Name**, **Last Name**, and **Email Address** from the Microsoft Forms' **Get response details** action. * Set the **Salary Amount** from the captured value in SignatureAPI's **Get a captured value** action. * Set the **Signed At** from SignatureAPI's **Wait for Envelope** action. Add row ### Retrieve the signed contract In SignatureAPI, the deliverable is a PDF containing the signed documents and the audit log. See an [example of a deliverable](/docs/integrations/power-automate/deliverables/audit-log). Retrieve the deliverable so you can save it later. 1. Add a **Get a deliverable** action from the **SignatureAPI** connector. 2. Set the **Deliverable ID** field to the **Deliverable ID** output of the previous **Wait for envelope** action. Use the **Deliverable ID** from the **Wait for envelope** step, not from **Create an envelope**, as the latter is always null (the deliverable is not generated yet). Get deliverable ### Save the signed contract to OneDrive Now, save the signed contract to OneDrive. 1. Add **Create File** action from the **OneDrive** connector. 2. Set the **File Name** field to your desired signed document name. You can use dynamic content from previous steps. Make sure to end it with `.pdf`. 3. Set the **File Content** field to the **File Content** output of the **Get a deliverable** action. Save file ### Notify HR that the contract was signed Finally, notify HR that the contract was signed and attach the signed document. 1. Add **Send an email (V2)** action from the **Outlook** connector. 2. Set the **To** field to the HR department email address. 3. Set the **Subject** and **Body** as you prefer, and use dynamic content from previous steps as needed. 4. Under **Attachments** in advanced parameters, set the attachment file name (ensure it ends with `.pdf`) and set the **Content** field to the **File Content** from the **Get a deliverable** action. Send email ## Test Your Automation Test the entire process end-to-end. 1. Save your Power Automate flow. 2. Submit a test response through your Microsoft Form. 3. Verify each step: * The form is submitted successfully. * The flow is triggered and the contract is sent to the employer. * After the employer fills the salary amount and signs, the employee receives and signs the contract. * A row is added to the Dataverse table with the employee details and captured salary amount. * The signed contract is saved in OneDrive. * HR receives an email notification with the signed contract attached. ## Conclusion In this tutorial, you learned how to use SignatureAPI together with Microsoft Forms, Power Automate, OneDrive, and Dataverse to automate the employment contract process. You saw how to fill a document template, add signature and input fields, and send documents to recipients for signing. You also learned how SignatureAPI captures additional data from recipients, tracks the status of the envelope, and provides a signed deliverable once the process is completed. The tutorial showed you how to automatically save signed contracts and employee details, streamlining your workflow. With these steps, you can now use SignatureAPI to manage and automate other document signing processes in your organization. ## Keep Learning * Learn about [document templates](/docs/integrations/power-automate/documents/templates). * Learn about [other type of places](/docs/integrations/power-automate/places/place) like initials, dates, etc. * Learn how to [customize your envelopes](/docs/integrations/power-automate/envelopes/envelope), set the language, and more. * Learn more about [capturing signer input](/docs/integrations/power-automate/envelopes/captures). **Happy Automating!** # Guides Overview Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/overview Tutorials and how-to guides for building SignatureAPI workflows in Power Automate ## Tutorials Tutorials walks you through complete workflows from start to finish. It’s great if you're new or want to see how everything fits together. Each tutorial shows how to build a working example using SignatureAPI, covering setup, key features, and tips along the way. ### Quickstart The Quickstart is a simple tutorial to help you create, send, and retrieve signed documents with SignatureAPI. Perfect for quickly exploring core features. In the Quickstart you will learn: * How to fill a document template with data using SignatureAPI. * How to send documents for signature and track their status. * How to retrieve the signed document and save it. * How to use the Dashboard to read emails while in test mode. * What the signing experience looks like. ### Intermediate Tutorial The Intermediate Tutorial dives deeper into SignatureAPI, showing you how to handle multi-signer workflows, custom fields, and data collection. Ideal for more advanced use cases and automation. In this tutorial you will learn: * How to fill a document template with data using SignatureAPI. * How to set up signature and input fields in your document. * How to send documents to multiple signers using SignatureAPI. * How to collect additional information from signers during the signing process. * How to send documents for signature and track their status. * How to retrieve the signed document and save it. ## How-To Guides How-To guides show you how to complete specific tasks using SignatureAPI. Each guide focuses on one feature or use case, with clear steps and examples to help you get it done quickly. Learn how to filter triggers in Power Automate to only trigger a flow for specific envelopes, not all in your SignatureAPI account. Learn how to handle issues in your e-signature flows using Power Automate. This guide also explains how to work with triggers to control when your flows start. Find out how to retrieve completed documents from SignatureAPI in Power Automate and automatically deliver or store them wherever you need. # Power Automate Quickstart Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/guides/quickstart Create a consent form from a DOCX template and send it for signature in Power Automate ## Overview In this quickstart, we'll create a Dummy Consent form from a docx template and send it to a recipient for signature using Power Automate and SignatureAPI. ### What you'll learn * How to fill a document template with data using SignatureAPI. * How to send documents for signature and track their status. * How to retrieve the signed document and save it. * How to use the Dashboard to read emails while in test mode. * What the signing experience looks like. ## Getting Everything Ready Before building the Power Automate flow, let's make sure we have everything ready. ### Get Your Test API key Sign up for a free account to get your test API key. Use it to generate non-binding envelopes and test your integration with SignatureAPI. To get started, sign up for a free test [API key](/docs/integrations/power-automate/authentication). Test API keys let you create test envelopes, great for trying out your workflows. Envelopes in test mode: * Don’t send emails to recipients, but you can see them in the Email area of your dashboard. * Are not legally-binding, so no legal obligations arise during testing. * Are free. Learn more about [test API keys](/docs/integrations/power-automate/authentication#test-vs-live-mode). ### Prepare the Template Before building the Power Automate flow, let's look at the DOCX document we'll use as our template. You can [download it here](https://pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/dummy-consent.docx) and open it in Microsoft Word. In the document, we've added fields like `{{personName}}` and `{{companyName}}`. These placeholders will be replaced with actual data when the document is generated. We've also included a conditional statement `{{if showStatement}}` that will insert the text "THIS IS A NON-BINDING..." only if the `showStatement` value is set to `true`. On the second page, we've added a signature placeholder `[[consentor_signature]]` for the recipient's signature (we'll refer to the recipient as "Consentor" in this example). For visibility, we've made the placeholder font blue in this example, but we recommend setting the font color to white so it remains hidden in the final document. ## Building the Power Automate Flow In Power Automate, create a new **Instant cloud flow**. Give it a name and choose **Manually trigger a flow** as the trigger. ### Download the Template We'll use Power Automate's HTTP action to download the template from a URL. Alternatively, you can store and retrieve the template from OneDrive, Dropbox, or another file source. * Add a new **HTTP** action to your flow. * Set the **Method** to `GET`. * In the **URI** field, enter `https://pub-9cb75390636c4a8a83a6f76da33d7f45.r2.dev/dummy-consent.docx`. This action will download the template file, which we'll use later when adding a template to the envelope. ### Create an Envelope Next, we'll create an envelope using SignatureAPI. An envelope is a container for the documents and recipients involved in the signing process. * Add the **Create an envelope** action from SignatureAPI to your flow. * If you're using SignatureAPI for the first time, you'll need to create a new connection: * For **Connection Name**, use any name you prefer (e.g., **SignatureAPITest**). * In **API Key**, enter your SignatureAPI key, which you can find in the SignatureAPI Dashboard under **Settings > API Keys**. Once connected, configure the **Create an envelope** action: * Set the **Envelope title** and **Envelope message**. These will be visible to the recipient. * In the **Advanced Options**, you can set localization settings (language, time formats, time zones) and other advanced features. ### Add a Recipient - Signer Now, we'll add the signer recipient to the envelope. * Add the **Add a recipient - Signer** action from SignatureAPI to your flow. Configure the **Add a recipient - Signer** action: * **Recipient Name**: Enter the recipient's name (e.g., `John Doe`). * **Recipient Email**: Enter the recipient's email address (e.g., `john@example.com`). * **Recipient Key**: Use the same key you used in the signature placeholder in your template (in this case, `consentor`). * **Envelope ID**: Select the **Envelope ID** output from the **Create an envelope** action. ### Add the Template to the Envelope We'll now add the DOCX template to the envelope. * Add the **Add a template - DOCX** action from SignatureAPI to your flow. Configure the **Add a template - DOCX** action: * **File Content**: Set this to the **Body** output of the **HTTP** action we used to download the template. * **Envelope ID**: Select the **Envelope ID** output from the **Create an envelope** action. * **File Format**: Keep this as `docx`. * **Template Data**: For each field or conditional in your template, add a new **Template Data Item** as a `Key: Value` pair in the **Template Data**. The **Key** being the field name (without the `{{ }}`) and the **Value** being the data you want to insert. This will be used to populate the template. * To fill the `personName` field with `John Doe`, add the following item: `personName: John Doe` * To fill the `companyName` field with `Doe Enterprises, LLC`, add the following item: `companyName: Doe Enterprises, LLC`. * To set the conditional `showStatement` to `true`, add the following item: `showStatement: true`. * For the `companyName` field, set the **Value** to `Doe Enterprises, LLC`. * For the conditional `showStatement`, set the **Value** to `true`. ### Add the Signature Place Now that we've set up the envelope template, we'll add the signature place to the document. * Add the **Add a place - Signature** action from SignatureAPI to your flow. Configure the **Add a place - Signature** action: * **Place Key**: Enter the place key you used in the signature placeholder in your template (in this case, `[[consentor_signature]]`). * **Recipient Key**: Select the **Recipient Key** output from the **Add a recipient - Signer** action. * **Document ID**: Select the **Document ID** output from the **Add a template - DOCX** action. ### Start the Envelope Now that we've set up the envelope with the recipient and template, we'll start the signing process. * Add the **Start an envelope** action from SignatureAPI to your flow. Configure the **Start an envelope** action: * **Envelope ID**: Select the **Envelope ID** output from the **Create an envelope** action. ### Wait for the Envelope to Complete After starting the envelope, we need to wait until all recipients have signed and the signed document is ready. * Add the **Wait for envelope** action from SignatureAPI to your flow. This action pauses the flow for up to 30 days until the process is complete. Configure the **Wait for envelope** action: * **Envelope ID**: Select the **Envelope ID** output from the **Create an envelope** action. ### Retrieve the Deliverable Once the envelope is complete and the deliverable is generated, we'll retrieve it. The deliverable is a tamper-proof document that includes the signed document and the audit log. * Add the **Get a deliverable** action from SignatureAPI to your flow. Configure the **Get a deliverable** action: * **Deliverable ID**: Select the **Deliverable ID** output from the **Wait for envelope** action. > **Important:** Use the **Deliverable ID** from the **Wait for envelope** action, not from the **Create an envelope** action, because the latter does not contain the completed deliverable. The **Get a deliverable** action outputs a **File Content** property containing the PDF file of the deliverable. You can use this **File Content** in any Power Automate action that accepts files, such as OneDrive's **Create file** action. ## Running the Flow In Power Automate, click on **Test** to run your flow. The flow will start running. If everything is set up correctly, you should see green checkmarks on all steps up to **Start an envelope**. The **Wait for envelope** action will be in a waiting state until the envelope is completed and the deliverable is generated. ### Sign the Envelope The envelope has been sent to the recipient, John Doe, at `john@example.com`. Since we're using a test API key, real emails are not sent. However, you can preview the email in the SignatureAPI Dashboard. * Log in to your SignatureAPI Dashboard. * Navigate to the **Envelopes** list and select your newly created envelope. In the envelope details, scroll down to the **Emails** section and click on the email sent to John Doe. You can preview the email to see how it would appear to the recipient. Click on the blue button in the email preview to access the signing ceremony as John Doe. ### Sign the Document as John Doe You'll now experience the signing process from John Doe's perspective. Go through the signing ceremony and sign the document. ### Verify the Envelope Status After signing, return to the SignatureAPI Dashboard to check the status of the envelope and ensure that everything is progressing smoothly. ### Check the Power Automate Flow Go back to your flow run in Power Automate. If the steps are still processing, wait a few minutes or refresh the page. The deliverable may take a few minutes to generate. Once the flow has completed successfully, you can go to OneDrive (or whichever app you used to store the deliverable) to download and view the final document. # Date Places Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/places/date Auto-insert completion dates for recipients or envelopes in Power Automate flows This designates an area within the document to record the date where a [single recipient](#recipient-completed-date) or [all recipients](#envelope-completed-date) completed a document. You can position Date Places inside a document using either [fixed positions](/docs/integrations/power-automate/places/positioning#fixed-positions) or [placeholders](/docs/integrations/power-automate/places/positioning#placeholders). ## Recipient Completed Date This designates an area within the document to record the date when the recipient, identified by `recipient_key`, completed their action (for example, signing) within the envelope. Use the [Add a place: Recipient Completed Date](/docs/integrations/power-automate/actions/add-place-recipient-completed-date) action to add a recipient completed date place to a document within an envelope. ## Envelope Completed Date This indicates a location within the document to capture the date when the entire envelope was completed, meaning all recipients have completed their actions (for example, signing). Use the [Add a place: Envelope Completed Date](/docs/integrations/power-automate/actions/add-place-envelope-completed-date) action to add an envelope completed date place to a document within an envelope. # Initials Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/places/initials Add initials fields to documents in Power Automate using the Add Place action An **Initials Place** is a type of [Place](/docs/integrations/power-automate/places/place) that marks a specific area in the document where the recipient, as identified by the `recipient_key`, can place their initials. You can position initial places inside a document using either [fixed positions](/docs/integrations/power-automate/places/positioning/#fixed-positions) or [placeholders](/docs/integrations/power-automate/places/positioning/#placeholders). Use the [Add a place: Initials](/docs/integrations/power-automate/actions/add-place-initials) action to add an initials place to a document within an envelope. # The place Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/places/place Define signature fields, input areas, and auto-filled values in Power Automate workflows **Places** are designated areas within a document where a recipient either provides input, such as a signature, or where a constant or calculated value is added, like a completion date. To define a place, you need to specify both a [place object](#place-objects) and a [position](#place-positioning), either by using a [placeholder](#placeholders) within the document or by setting [fixed positions](#fixed-positions) with coordinates. If you want to generate a document using a template and dynamic data before any recipient signs, use [Document Templates](/docs/integrations/power-automate/documents/templates) instead Places are defined in the `places` array within the document object. Each element in the array represents a place within the document. The properties of each place depend on its type. For example, a [signature](#signature-place) place will include information about the recipient expected to sign, while a date place, such as [envelope completed date](#envelope-completed-date), can specify the format for the date-time string. ## Relationships A place belongs to a [document](/docs/integrations/power-automate/documents/document) # Place positioning Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/places/positioning Position fields using text placeholders or fixed coordinates in Power Automate Places can be positioned in the document using either a [placeholder](#placeholders) or a [fixed position](#fixed-position). ### Placeholders You can define placeholders inside your document using the template `[[place_key]]`, where `place_key` corresponds to the key of the place. For example, to define placeholders for two places with the keys `licensor_signs_here` and `licensor_signed_at` in the document: In this example, to show the placeholders in the document, we set them to a blue color. You can set the text color of the placeholder to white to hide it from recipients. Placeholder positioning Then we define the `licensor_signs_here` as a **Signature** place: And `licensor_signed_at` as a **Recipient Completed Date** place: The `licensor_signs_here` place will appear over the placeholder `[[licensor_signs_here]]`, and the `licensor_signed_at` place will appear over the placeholder `[[licensor_signed_at]]`. Placeholder positioning signed You can set the text color of the placeholder to white to hide it from recipients. Placeholder positioning signed white text ### Fixed Positions Sometimes, you can to position places in a specific coordinate within a page in the document. Fixed positions can be defined by specifying the page number, along with distances from the top of the page (`top`) and from the left side of the page (`left`). Both `top` and `left` are measured in points (1/72 of an inch), and can have decimal places. For example, to define a fixed position for a place with the key `employer_first_signature`, located in the second page, 1 inch (72 points) from the left and 5 inches (360 points) from the top of the page: Each place is positioned on the page based on the coordinates of its bottom-left corner, as shown in the image below. Fixed place positioning # Signature Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/places/signature Add signature fields to documents in Power Automate using the Add Place action A **Signature Place** is a type of [Place](/docs/integrations/power-automate/places/place) that marks a specific area in the document where the recipient, as identified by the `recipient_key`, can place their signature. You can position Signature Places inside a document using either [fixed positions](/docs/integrations/power-automate/places/positioning/#fixed-positions) or [placeholders](/docs/integrations/power-automate/places/positioning/#placeholders). Use the [Add a place: Signature](/docs/integrations/power-automate/actions/add-place-signature) action to add a signature place to a document within an envelope. # Text Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/places/text Insert static text strings at specific document locations in Power Automate flows Text places let you insert a specific string at a location in the document. You can position Text Places inside a document using either [fixed positions](/docs/integrations/power-automate/places/positioning/#fixed-positions) or [placeholders](/docs/integrations/power-automate/places/positioning/#placeholders). Use the [Add a place: Text](/docs/integrations/power-automate/actions/add-place-text) action to add a text place to a document within an envelope. You can use text places with fixed positions to fill in PDF forms before the first recipient signs. # Text Input Place Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/places/text-input Collect information from recipients with text input fields in Power Automate flows **Text input places** allow you to request specific information from recipients during the signing ceremony. These are similar to *fields* in other electronic signature platforms. Input fields are only available in envelopes with sequential signing. You can position Text Input Places inside a document using either [fixed positions](/docs/integrations/power-automate/places/positioning/#fixed-positions) or [placeholders](/docs/integrations/power-automate/places/positioning/#placeholders). Use the [Add a place: Text Input](/docs/integrations/power-automate/actions/add-place-text-input) action to add a text input place to a document within an envelope. ## Hints and Prompts You can use `hint` and `prompt` properties to guide recipients while filling out text fields: * **Hint**: A message shown as a tooltip when the user hovers over or focus on the text field. Set it using the `hint` property. * **Prompt**: A placeholder-style message displayed inside the text field. Set it using the `prompt` property. For example, a text input place configured with the following properties: During the signing ceremony, the field will appear like this: ## Format Validation The `format` property allows you to control the type of input users can enter into a field. This property can accept either predefined formats or custom regular expressions. ### Predefined Formats You can use one of the following predefined values: | Format | Description | | ------------ | ------------- | | `email` | Email address | | `zipcode-us` | US ZIP code | More predefined formats are coming soon! Have a specific format in mind? [Let us know](https://signatureapi.com/support). ### Custom Regular Expressions If the predefined formats don’t meet your needs, you can define a custom format using a regular expression. Enclose the regular expression in forward slashes. For example, to require exactly 8 numeric digits: ### Adding a Custom Message To guide users during input, you can include a `format_message` property. This message is displayed when the input doesn’t match the required format. For example: During the signing ceremony, the `format_message` is displayed to help users understand the input requirements: ## Example For example, a text input field can be used to place a text box at the placeholder **\[\[buyer\_email]]**. This allows the recipient with the key "buyer" to provide their email address. This field is set to optional. ## Parameters Specifies the type of place. For a text place, the value must be `text_input`. A user-provided key that identifies a place within a document. It must be up to 32 characters long, using only lowercase letters, numbers, or underscores, and it must begin with a letter. A user-provided key that identifies a recipient within an envelope. It must match to one of the keys in the envelope's recipient list. A user-defined identifier used to store the value entered by the recipient. This value will be included in the `captures` object of the Envelope. A tooltip message displayed over the input text field during the signing ceremony. A placeholder message shown inside the input text field during the signing ceremony. Specifies whether the recipient must fill this field to complete the signing ceremony. Possible values are `required` or `optional`. The default is `required`. Defines the validation format for the user's input. Accepted values are `email` or `zipcode-us`. Alternatively, a regular expression can be used, enclosed in forward slashes. Learn more in [Format Validation](#format-validation). The message displayed when the user's input does not match the required format. Learn more in [Adding a Custom Message](#adding-a-custom-message). # Quickstart Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/quickstart Build your first SignatureAPI flow in Power Automate in minutes # Custom Authentication Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/recipients/authentication/custom Authenticate recipients through your own workflow and share signing URLs directly With **custom authentication**, your workflow or your app authenticate the [recipient](/docs/integrations/power-automate/recipients/recipient). SignatureAPI provides a URL you can share directly with recipients to start the signing ceremony. ## When to Use Custom Authentication Email link authentication works well for simple use cases but has some limitations: * You cannot access the ceremony URL to send via other channels. * It interrupts your application's flow because recipients must check their email. * You cannot control when or how the email is sent. With **custom authentication**, you authenticate recipients yourself and share authentication details with SignatureAPI. SignatureAPI sends you the ceremony URL, which you can: * Share with recipients via email or SMS. * Redirect recipients directly to the ceremony. * Embed into your application. ## Ceremony Creation To use custom authentication, create an envelope and set the recipient's `ceremony_creation` to `manual`. Example API request: Use the recipient ID (from the envelope creation response) to create the ceremony with `authentication_type` set to `custom`. Provide the following authentication data: * `provider`: The name of the application or company authenticating the recipient. * `data`: Key-value pairs containing details like timestamps or session IDs. Example custom authentication request: The values provided in `data` should clearly link to the recipient's authentication session in your system. Keep logs and session details that can easily link the recipient's identity to the envelope. For more details, see our [**Terms & Conditions**](https://signatureapi.com/terms). ## Authentication Provider Set the **provider** property to the name of the company or app authenticating the recipient. It will be included as-is in the audit log, like this: > John Doe has been authenticated by \[Provider Name] ## Custom Authentication Data The `data` property contains key-value pairs with authentication details. These details appear in the envelope's audit log and help link the ceremony to the authentication session in your system. In special cases, such as legal proceedings, you may need to provide your internal records to confirm that the recipient was properly authenticated. Good examples of authentication data include: * **Session Data:** Recommended for linking recipient sessions in your system to the ceremony. Include Session IDs and session start timestamps. * **User Identification:** If sending URLs by email, include recipient emails. If using SMS, include recipient phone numbers. You can also include unique user IDs from your system. * **Authentication Event Details:** Clarify the method used, such as OTP or biometrics, and add device IDs, IP addresses, or geolocation data. * **Other Data:** Hashes, nonces, transaction IDs, or other unique references. Examples: * `Session ID: a4f9e8b2-7c1d-4b2d-9a4b-e0c5d6f7a1b3` * `Order Reference: 25005` * `Authentication Timestamp: 2025-12-31T10:00:00Z` * `Authentication Method: SMS` * `Phone Number: +1-111-1111111` Carefully check authentication data to avoid sending sensitive recipient details. ## Using the Ceremony URL After creating a custom-authenticated ceremony, you receive the Ceremony URL. With this URL, you can: * Send customized emails with your branding and domain. * Embed the ceremony into your application. * Redirect recipients from your application directly to the ceremony. Treat Ceremony URLs as sensitive data. Do not expose them in public forums or share them with unauthorized users. ## Audit Log When recipients access a ceremony using custom authentication, the timestamp, `provider`, and authentication `data` are recorded in the Audit Log. ![](https://whimuc.com/QQDubRnfFPHF1uvj5mB5n8/8aaeJEuUJMhJ1Y.png) ## Next Steps * Learn how to [embed the ceremony](#). * Review our [Terms & Conditions](https://signatureapi.com/terms). # Email Link Authentication Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/recipients/authentication/email-link Default authentication method that sends recipients email links to start signing With **email link authentication**, SignatureAPI sends [recipients](/docs/integrations/power-automate/recipients/recipient) an email containing a link to start the ceremony. This is the default authentication method for SignatureAPI. When you create an envelope, recipients receive an email with a URL directing them to the ceremony. Email link authentication is simple, widely used, and recognized. It suits most use cases. ## Automatic vs Manual By default, SignatureAPI automatically creates ceremonies and sends authentication links via email. You might prefer to create ceremonies manually if you need to: * Control when emails are sent. * Redirect recipients to another site after completing the ceremony. ### Manual Ceremony Creation To manually create a ceremony, set the recipient's **Ceremony Creation** to `manual` when creating the envelope. SignatureAPI will not create the ceremony or send emails automatically. When you are ready, manually create a ceremony using the `email_link` authentication method. You can also set a `redirect_url` to direct recipients to another website after they complete the ceremony. See the reference links at the bottom of this page to learn how to manually create a ceremony using the API or other platforms. ## Audit Log When recipients click the email link, they are automatically authenticated, and SignatureAPI records the timestamp for auditing purposes. The audit log indicates when email link authentication is used: ## Email Customization SignatureAPI emails have a standard template. You can customize the following: * Email subject (taken from the envelope title) * Email message body (taken from the envelope message) * Email language (taken from the envelope language) For example, an envelope with: * `title`: Dummy Agreement * `message`: Please review the agreement at your convenience and provide your electronic signature. will produce an email similar to this: If you need further email customization or want to use your own domain and email provider, you can use custom authentication to get the ceremony URL and build and send the customized email from your infrastructure. ## Next Steps # Recipient Authentication Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/recipients/authentication/overview Choose between email link or custom authentication methods for signing ceremonies A ceremony is the session where a [recipient](/docs/integrations/power-automate/recipients/recipient) interacts with an [envelope](/docs/integrations/power-automate/envelopes/envelope) and its documents, for example, to sign them. SignatureAPI offers two methods to authenticate recipients before starting the ceremony. ## Link via Email SignatureAPI authenticates the recipient by sending them an email containing a link. The link leads directly to the ceremony, where the recipient can sign documents. This is the default authentication method. ## Custom Authentication Your service (or another external service) authenticates the recipient. You send the authentication data to SignatureAPI, which we then include in the envelope's audit log. SignatureAPI provides a Ceremony URL, which you can: * Share directly with the recipient * Redirect the recipient to * Embed in your application ## Audit Log Records When a recipient accesses the ceremony, SignatureAPI logs their authentication event. Each event includes the date, time, and IP address, which appear in the audit log. SignatureAPI adds a new authentication record to the audit log each time the recipient accesses the ceremony. If the recipient accesses it multiple times, the audit log will contain several entries reflecting each access. ## URL Expiration All ceremony links expire after 30 days by default, or are revoked when: * You create a new ceremony for the same recipient. * The recipient completes the envelope (for example, by signing the documents). The expiration period can be customized. Contact [support](mailto:support@signatureapi.com) to configure a different expiration time for your account. # The recipient Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/recipients/recipient Signers and other recipients who interact with envelope documents in Power Automate A **recipient** is a person who receives an envelope. A **signer** is a type of recipient. Recipients interact with the [documents](/docs/integrations/power-automate/documents/document) in an [envelope](/docs/integrations/power-automate/envelopes/envelope) during a Ceremony. These interactions may include signing, initialing, or filling in information. Once recipients successfully complete all required actions within the envelope, their status is marked as complete. ## Relationships A recipient belongs to an [envelope](/docs/integrations/power-automate/envelopes/envelope) ## Lifecycle The recipient’s `status` field indicates its current stage, tracking interaction and progress. Possible recipient status are: | | | | -------------- | ---------------------------------------------------------------------------------------------------------------- | | `awaiting` | The recipient is waiting for previous recipients to complete the envelope. | | `pending` | The envelope has not been sent yet to the recipient. | | `sent` | The envelope has been sent to the recipient. | | `completed` | The recipient has completed the envelope. | | `rejected` | The recipient has declined to complete the envelope. | | `soft_bounced` | The email to the recipient was temporarily undeliverable. | | `hard_bounced` | The email to the recipient was permanently undeliverable, maybe because the email address doesn’t exist anymore. | | `failed` | An error ocurred and the email could not be sent to the recipient. | | `replaced` | The recipient was replaced with another one. | # Redirect URL Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/recipients/redirect-url Configure where recipients are redirected after completing signing ceremonies After a ceremony is finished, whether successful or not, we can redirect to the `redirect_url` defined in a ceremony created manually: * [Custom authentication](/docs/integrations/power-automate/actions/create-ceremony-custom#param-redirect-url) * [Email link authentication](/docs/integrations/power-automate/actions/create-ceremony-email-link#param-redirect-url) Upon redirection, the following query parameters are appended to the URL: | Parameter Name | Description | | :---------------- | :------------------------------------------------------------------------------------------- | | `envelope_id` | The ID of the envelope. | | `recipient_id` | The ID of the recipient. | | `ceremony_result` | The result of the ceremony: `ceremony.completed`, `ceremony.declined`, or `ceremony.failed`. | For example, if the `redirect_url` is set to `https://www.example.com`, after a successful ceremony it will redirect to: `https://www.example.com/?ceremony_result=ceremony.completed&envelope_id=5b7be28c-6c7c-4aaa-b25f-66879e8d0957&recipient_id=re_0sgQC0cejYRC8wRsT5N9ll` You can use these query parameters to process the ceremony result in your application. # Triggers Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers Start Power Automate flows when envelopes complete, recipients sign, or emails bounce A **trigger** is an event that starts a flow. In Power Automate, you can use triggers to start a flow when something happens in an envelope, a recipient, or a deliverable. For example, you can start a flow when a deliverable (the signed document) is generated, or when an email to a recipient bounces. ## Filtering Triggers You can filter triggers using **topics**. This allows you to limit events to only the envelopes you're interested in. Learn more in [Topics](/docs/integrations/power-automate/envelopes/topics). ## Most Used Triggers SignatureAPI offers [a full set of triggers](#all-triggers) to help you automate your workflows. Below are some of the most commonly used ones: ### When a deliverable is generated Most electronic signature workflows use two flows: 1. A flow that creates an envelope, usually triggered by an event in another app (for example, when a new customer is added to a CRM). 2. A second flow that runs when the envelope is completed. It retrieves the deliverable (the signed document) and uses it, such as storing it in a document repository or sending it to a supervisor. For the second flow, use the **When a deliverable is generated** trigger. This trigger runs when the envelope is completed and the deliverable PDF is created. You can then retrieve the PDF and use it in your flow. Triggered when a deliverable, such as an audit log, is successfully generated. ### When a recipient is completed The **When a recipient is completed** trigger runs when a recipient finishes their part of the signing process. You can use it to start a flow that sends a notification or updates another system (such as a SharePoint list). Triggered when a recipient completes their part of the signing process. ## All Triggers ### Envelope Triggers Triggered when an envelope is created. Triggered when an envelope status changes from **processing** to **in\_progress**, indicating it is ready to be sent to recipients. Triggered when an envelope status changes from **in\_progress** to **completed**, indicating it has been completed by all recipients. Triggered when the signing process is intentionally stopped before completion, resulting in an envelope status of **canceled**. Triggered when an envelope fails, resulting in an envelope status of **failed**. ### Recipient Triggers Triggered when a recipient is ready to be sent a request to complete an envelope. Triggered when a request is sent to a recipient. Triggered when a recipient completes their part of the signing process. Triggered when a recipient is replaced with a new one. Triggered when a request is resent to a recipient. Triggered when a request email to a recipient is undeliverable, either temporarily (soft bounce) or permanently (hard bounce). Triggered when there is a failure related to a recipient, resulting in a recipient status of **failed**. Triggered when a recipient rejects completing (for example, signing) the envelope. ### Deliverable Triggers Triggered when a deliverable, such as an audit log, is successfully generated. Triggered when the generation of a deliverable fails, resulting in a deliverable status of **failed**. ## Troubleshooting # When a deliverable fails Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/deliverable-failed This event occurs when the generation of a deliverable fails, resulting in a deliverable status of failed. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. The ID of the deliverable this event refers to. Information about the failure. # When a deliverable is generated Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/deliverable-generated This event occurs when a deliverable, such as an audit log, is successfully generated. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. The ID of the deliverable this event refers to. # When an envelope is canceled Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/envelope-canceled This event occurs when the signing process has been intentionally stopped before completion, resulting in an envelope status of canceled. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. # When an envelope is completed Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/envelope-completed This event occurs when an envelope status transitions from in_progress to completed, indicating it has been completed by all recipients. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. # When an envelope is created Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/envelope-created This event occurs whenever an envelope is created. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. # When an envelope fails Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/envelope-failed This event occurs when an envelope fails, resulting in an envelope status of failed. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. Information about the failure. # When an envelope has started Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/envelope-started This event occurs when an envelope status transitions from processing to in_progress, indicating it is ready to be sent to recipients. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. # When a recipient bounces Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/recipient-bounced This event occurs when an email is undeliverable, either temporarily (soft-bounce) or permanently (hard-bounce). ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. The ID of the recipient this event refers to. The type of recipient this event refers to. The key of recipient this event refers to. Information about the bounce. # When a recipient is completed Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/recipient-completed This event occurs when a recipient has completed their part of the signing process. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. The ID of the recipient this event refers to. The type of recipient this event refers to. The key of recipient this event refers to. # When a recipient fails Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/recipient-failed This event occurs when there is a failure related to a recipient, resulting in a recipient status of failed. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. The ID of the recipient this event refers to. The type of recipient this event refers to. The key of recipient this event refers to. Information about the failure. # When a recipient rejects Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/recipient-rejected This event occurs when a recipient rejects the ceremony. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. The ID of the recipient this event refers to. The type of recipient this event refers to. The key of recipient this event refers to. The recipient's explanation for the rejection. # When a recipient is released Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/recipient-released This event occurs when a recipient is ready to be sent a request to complete an envelope. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. The ID of the recipient this event refers to. The type of recipient this event refers to. The key of recipient this event refers to. # When a recipient is replaced Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/recipient-replaced This event occurs when a recipient is replaced with a new one. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. The ID of the recipient this event refers to. The type of recipient this event refers to. The key of recipient this event refers to. The ID of the new recipient. # When a recipient is resent Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/recipient-resent This event occurs when a request is resent to a recipient. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. The ID of the recipient this event refers to. The type of recipient this event refers to. The key of recipient this event refers to. # When a recipient is sent Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/triggers/recipient-sent This event occurs when a request is sent to a recipient. ### Input Use to classify envelopes and filter webhook notifications. ### Output The ID of the event. The date and time of the event, in ISO 8601 format. The type of the event. The ID of the envelope this event refers to. The ID of the recipient this event refers to. The type of recipient this event refers to. The key of recipient this event refers to. # Troubleshooting Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/power-automate/troubleshooting Debug failed Power Automate flows and resolve common SignatureAPI integration errors If your flow run fails, you can check the run history to find out what went wrong.\ The run history shows the status of each step in your flow, including any errors. ### How to check a failed run In Power Automate, open your flow, go to the **Run History**, and select the run that failed. Find the failed step (with the red ) and select it. In the right pane, look under **Outputs**. The **body** section in Outputs contains details about the error: * The `type` parameter is a URL to a page with more information about this error. * The `detail` parameter provides more information about this specific error. You may need to scroll down in the body section to see these parameters. If you're stuck or need help understanding the error, [contact our support team](https://signatureapi.com/support). We're here to help. # SignatureAPI for Zapier Source: https://signatureapi-daf4ee54.mintlify.app/docs/integrations/zapier/overview Connect SignatureAPI with thousands of apps using the Zapier integration (private preview) We are currently offering a **private preview** of our Zapier connector. If you're interested in trying SignatureAPI with Zapier, please [contact us](https://signatureapi.com/contact-us) to request access. # California CCPA Compliance at SignatureAPI Source: https://signatureapi-daf4ee54.mintlify.app/docs/trust/compliance/ccpa SignatureAPI complies with California CCPA and CPRA privacy requirements SignatureAPI complies with the **California Consumer Privacy Act (CCPA)**, as amended by the **California Privacy Rights Act (CPRA)**, where applicable. This page provides a brief overview of what CCPA is and how our compliance commitments are addressed contractually. ## What is CCPA? The California Consumer Privacy Act (CCPA) is a California state privacy law that governs how businesses collect, use, and disclose personal information of California residents. The CPRA expands and amends the CCPA, adding additional consumer rights and obligations around data processing and protection. Together, these laws establish requirements related to transparency, consumer rights, data use limitations, and security safeguards. ## CCPA at SignatureAPI When customers use SignatureAPI, they act as the **business** (or controller), and SignatureAPI acts as a **service provider**, processing personal information only to provide the services described in our Terms and on the customer’s instructions. SignatureAPI does not sell or share customer personal information as those terms are defined under CCPA, and processes personal information solely for permitted business purposes. ## Data Processing Addendum (DPA) SignatureAPI’s CCPA and CPRA obligations are governed by our **Data Processing Addendum (DPA)**, which forms part of our Terms and Conditions. The DPA defines our role as a service provider, limits data use, and sets out security and confidentiality commitments. You can review the full DPA here: [Data Processing Addendum](/docs/legal/terms/dpa). # GDPR Compliance at SignatureAPI Source: https://signatureapi-daf4ee54.mintlify.app/docs/trust/compliance/gdpr SignatureAPI complies with EU and UK GDPR requirements for processing personal data SignatureAPI complies with the **EU General Data Protection Regulation (GDPR)** and the **UK GDPR** where applicable. This page provides a brief overview of what GDPR is and how our compliance commitments are addressed contractually. ## What is GDPR? The General Data Protection Regulation (GDPR) is a data protection law that applies to the processing of personal data of individuals in the European Union and European Economic Area. The UK GDPR is the United Kingdom’s equivalent framework, based on the GDPR and incorporated into UK law following Brexit. Together, these laws establish requirements around lawful processing, data security, transparency, and individual rights. ## GDPR at SignatureAPI When customers use SignatureAPI, they act as the **data controller**, and SignatureAPI acts as a **data processor**, processing personal data only on the customer’s documented instructions and to provide the services described in our Terms. Our obligations under EU and UK GDPR (including security measures, subprocessors, international data transfers, and data subject rights assistance) are set out in our Data Processing Addendum. ## Data Processing Addendum (DPA) SignatureAPI’s GDPR commitments are governed by our **Data Processing Addendum (DPA)**, which forms part of our Terms and Conditions. You can review the full DPA here: [Data Processing Addendum](/docs/legal/terms/dpa). # HIPAA Compliance at SignatureAPI Source: https://signatureapi-daf4ee54.mintlify.app/docs/trust/compliance/hipaa Configure SignatureAPI for HIPAA-compliant handling of protected health information with BAA support SignatureAPI supports HIPAA compliance for organizations handling protected health information (PHI). This page explains how to use SignatureAPI in a HIPAA-compliant manner and highlights key safeguards and configuration steps. ## What is HIPAA? HIPAA (Health Insurance Portability and Accountability Act of 1996) is a U.S. law that sets standards for protecting sensitive health data. It applies to covered entities, such as healthcare providers and insurers, as well as their business associates (third parties that handle PHI on their behalf). HIPAA compliance requires administrative, technical, and physical safeguards to ensure the confidentiality, integrity, and availability of PHI. ## Business Associate Agreements (BAAs) SignatureAPI can sign Business Associate Agreements (BAAs) upon request, using the [Bonterms Standard Business Associate Agreement v1](https://bonterms.com/standard/business-associate-agreement-v1/) as our standard template. BAAs are not automatically extended to all customers. If you require a BAA, please contact us to initiate the process. ## Using SignatureAPI in a HIPAA-Compliant Way SignatureAPI offers features to help you securely handle PHI, but your compliance also depends on how you implement and configure these features. ### Secure Link Delivery by Email To protect PHI and comply with HIPAA, you must secure document links sent via email or SMS with secondary authentication. By default, SignatureAPI emails ceremony URLs directly to recipients, which could expose PHI if intercepted. HIPAA requires that only authorized individuals can access PHI, so you must verify recipient identity before granting access. #### Enforcing Secondary Authentication When sending ceremony URLs to recipients via unencrypted channels like email or SMS, you must configure additional authentication to ensure only authorized individuals can access documents containing PHI. SignatureAPI provides two secure options to ensure HIPAA compliance: 1. **SignatureAPI delivers ceremony links by email with additional authentication:** Configure the signing ceremony to use multiple authentication methods with both [Email Link and Email Code authentication](/docs/api/resources/ceremonies/authentication/multiple#email-link-%2B-email-code). This ensures recipients receive a ceremony link by email but must also enter a verification code (sent in a separate email) before accessing documents containing PHI. 2. **You deliver ceremony links by email with additional authentication:** Configure the ceremony to use [Email Code authentication](/docs/api/resources/ceremonies/authentication/email-code). This generates a ceremony URL that you can deliver through your own secure email or SMS channels. When recipients access the ceremony, they must enter a verification code (sent by SignatureAPI to their email) before they can view documents containing PHI. If you deliver links through a secure, authenticated portal, secondary authentication via SignatureAPI is not required. See [custom authentication](/docs/api/resources/ceremonies/authentication/custom) for more details. Never send direct-access links via unencrypted channels without secondary authentication. This risks PHI exposure and violates HIPAA requirements. ### Secure Deliverable Downloads with Authentication By default, deliverables are downloaded using short-lived, pre-signed URLs, which are sufficient for most use cases. However, when HIPAA is enabled on your account, downloading deliverables requires authentication using your API key, just like other API endpoints. This ensures secure, authorized access to files that may contain PHI. ### Configure Role-Based Access Controls HIPAA requires role-based access controls to ensure that access to PHI is limited to the minimum necessary for each user's job function (the principle of least privilege). Configure differentiated user permissions in your SignatureAPI dashboard to control who can access different types of PHI and system functions. Envelope-level access logs are available upon request. ## Best Practices ### Delete Envelopes Upon Completion We recommend that you delete envelopes as soon as they are completed. After an envelope is completed and the [deliverable is generated](/docs/api/resources/events/deliverable-events#deliverable-generated), download the deliverable and store it securely in your own system. This ensures that you retain access to the signed documents. Once you have downloaded the deliverable, send a [Delete Envelope request](/docs/api/resources/envelopes/delete) to initiate the deletion process. After deletion is complete, all envelope data is permanently removed from SignatureAPI. The downloaded deliverable can be [verified independently](/docs/api/resources/deliverables/verification), even if the envelope no longer exists in SignatureAPI. ### Don't Send Unencrypted Deliverables via Email To comply with HIPAA’s requirements for safeguarding PHI, never send unencrypted deliverables via email. Email is not a secure channel by default and may expose sensitive health information if intercepted. If you must send deliverables by email, ensure that the files are encrypted and that only the intended recipient can decrypt them. You can also provide access through a secure, authenticated portal instead of sending the file directly. For guidance on encrypting deliverables for secure transmission, contact SignatureAPI support. We can help you configure an encryption process that meets HIPAA standards. ## Enabling HIPAA Mode To enable HIPAA mode on your account: 1. Contact [SignatureAPI support](https://signatureapi.com/support) to request HIPAA mode and a BAA. 2. SignatureAPI enables HIPAA mode on your account and sends the BAA for signature. 3. Once the BAA is signed, configure your envelopes to use secondary authentication as described above. # SOC 2 Compliance at SignatureAPI Source: https://signatureapi-daf4ee54.mintlify.app/docs/trust/compliance/soc2 SignatureAPI is SOC 2 Type II compliant with independently audited security controls SignatureAPI is **SOC 2 Type II compliant**, with controls independently audited for design and operating effectiveness over time. ### What is SOC 2 Type 2? SOC 2 (System and Organization Controls 2) is a framework developed by the AICPA for managing customer data based on five “Trust Services Criteria” (TSC): Security, Availability, Processing Integrity, Confidentiality, and Privacy. A Type 2 report assesses how well these controls are implemented and operated over time. It’s widely used by companies that need to evaluate the reliability and security of third-party service providers, particularly those handling sensitive or regulated data. ### Our Scope Our SOC 2 Type 2 audit covers all five TSCs: * **Security** – Protection against unauthorized access. * **Availability** – System uptime and reliability. * **Processing Integrity** – Accurate and timely system operations. * **Confidentiality** – Protection of sensitive information. * **Privacy** – Handling of personal data in accordance with privacy principles. ### Get a copy of our SOC 2 Type 2 report To request a copy of our SOC 2 Type 2 report, email [support@signatureapi.com](mailto:support@signatureapi.com). ### Data Processing Agreement (DPA) If your organization requires a DPA, see our [Data Processing Agreement](/docs/legal/terms/dpa). The DPA covers GDPR, CCPA, UK GDPR, and cross-border data transfers.