Step 1
Create envelope from template
Your backend passes a template ID and the signers' details.
Step 2
Send for signature
WoltSign emails signing links and tracks each recipient.
Authenticated with your API key
API & Developers
Send documents for signature
directly from your
product
WoltSign connects to your HRIS, CRM, or internal tools via REST API. Your backend creates the envelope, assigns signers, and sends without anyone opening the WoltSign UI.
- REST API
- Template-based sends
- Workspace-scoped keys
- Webhook events
How it works
Your backend drives the full envelope lifecycle
Most teams start with two API calls: one to create an envelope from a template, one to send it. When you need more control, like your own PDFs, custom fields, or a specific signing order, the same API handles that too.
Envelope lifecycle
From creation through completion, your backend stays in control.
1. Create envelope
Your application
Pick a template or upload your own PDFs. Pass signer names and emails.
2. Assign signing order
Your application
Optional. Set which recipients sign first when sequence matters.
3. Send for signature
WoltSign
Signing links go to each recipient by email. WoltSign handles the browser-side experience.
4. Track status
Your application
Poll for envelope status or receive webhook events when signers act.
5. Record the outcome
Your application
Pull completed document data and audit events into your own systems.
Two calls from a template
Teams that have templates configured in WoltSign can go from zero to a sent envelope with a create call and a send call.
Full document control when you need it
Upload your PDFs, place signature and text fields on specific pages, and define a signing order. The API handles the whole pipeline.
Your workspace, your data
Every API call is scoped to a workspace. Recipients, envelopes, and templates stay inside the workspace that owns the key.
What you can build
One set of APIs for the full document workflow
WoltSign covers envelopes, templates, documents, signers, and folders over standard REST. Your integration can be a single automated send or a complete document pipeline built into your product.
Capabilities
Template to envelope
Your app passes a template ID and a list of signers. WoltSign copies the document layout, creates an envelope, and waits for you to send.
Build from scratch
Upload PDFs, assign roles, place signature and text fields on pages, set a signing order, and finalize, all before sending a single email.
Signer experience handled
Once sent, WoltSign handles the browser-side signing session. Your product stays the trigger and the record system.
Status and tracking
List envelopes by workspace, check individual status, and filter by folder. Useful for internal dashboards and ops reporting.
Organize with folders
File new envelopes into folders at create time. Keeps API-sent documents visible and organized for the ops team using the app.
REST and JSON
Standard HTTP verbs, JSON request and response bodies
API key auth
x-api-key header, server-side only
Workspace scoped
Every request tied to your workspace UUID
In-app examples
Each template generates a ready-made cURL request
Webhooks
Know the moment something happens
Register an HTTPS endpoint in WoltSign and receive a POST request every time an envelope moves through a lifecycle milestone. Update a database row, advance an onboarding step, or notify a Slack channel without polling the API.
How delivery works
HTTPS endpoints only. Register the URL in the WoltSign app.
Payloads are signed so your server can verify they came from WoltSign.
Subscribe per event type. You choose which events reach your endpoint.
Failed deliveries are retried. Details in /documentation.
Webhooks are configurable in the WoltSign app. Check documentation for rollout status in your environment.
Authentication
A workspace API key on every server-side request
Pass your API key in the x-api-key header. Every request also carries the workspace UUID that owns the data. Create and retire keys from the Integrations section of the WoltSign app. Keys belong in a secrets manager, not in client code or version control.
Getting started
- 1
Sign in at app.woltsign.com
- 2
Go to Integrations → API
- 3
Create an API key and copy it once. Store it in your secrets manager immediately
- 4
Include the key in the x-api-key header and your workspace_uuid in the request body
Server-side only
Never put API keys in browser code
Workspace bound
Keys only access data in the workspace that created them
Rotate any time
Create a new key before retiring the old one
In-app examples
Template detail pages include a prefilled request with your workspace UUID
Getting started
Pick a template, copy the example, wire it in
WoltSign is plain REST. Call it from whatever HTTP client your stack already uses. The fastest path to a working integration is inside the app: open any template, find the API Integration card, and copy the prefilled cURL for that template's create-and-send flow.
Integration path
Open template in app
Copy the cURL from the API Integration card
Replace YOUR_API_KEY and recipient details
POST to create envelope endpoint → receive envelope UUID
POST to send endpoint with UUID → signers receive email links
Developer documentation
Endpoint reference, auth guide, and webhook setup at /documentation
In-app cURL
Every template generates a copy-ready request with no manual JSON needed
Integrations hub
Create API keys and configure webhooks at app.woltsign.com/integrations/api
Help center
UI walkthroughs for templates, folders, and sending at /help-center
Security
Built for documents that carry weight
Signatures on employment contracts, vendor agreements, and compliance records need an infrastructure you can point auditors at. WoltSign keeps traffic encrypted, writes a timestamped audit trail, and scopes API access so integrations only touch the data they should.
TLS on every request
API calls and signing sessions run over TLS. Traffic between your backend and WoltSign stays encrypted in transit.
Tamper-evident audit trail
WoltSign records every send, open, signature, and completion with a timestamp. The history is there when you need it for compliance or disputes.
Workspace isolation
API keys are scoped to a workspace. One integration cannot read or write data owned by a different workspace.
Compliance resources
How WoltSign approaches ESIGN, UETA, and data handling is documented at /security.
Use cases
Automate signing where your systems already run
Each integration starts with a trigger your backend already understands: a hire confirmed, a deal advanced, a purchase order approved.
HR onboarding
A candidate is marked "hired" in your HRIS. Your backend creates an offer letter from a WoltSign template, assigns the new hire as signer, and sends before anyone on the HR team opens a browser.
Embedded signing
Your product takes users through a confirmation flow. At the final step your backend triggers the envelope. The signer clicks a link, signs, and returns to your product. Your UI stays the primary experience.
Procurement
A purchase order reaches "approved" in your ERP. Your backend generates a vendor agreement from the matching WoltSign template and routes it to the vendor for signature.
CRM deals
A deal moves to "Verbal yes" in Salesforce or HubSpot. Your integration creates an NDA or order form and sends it before the sales rep finishes their notes.
Internal compliance
An IT ticket for equipment or access triggers a policy acknowledgment. WoltSign handles the signature and stores the completed record. Your ticketing system tracks the status.
FAQ
Common questions about the WoltSign API
What engineering teams ask before wiring WoltSign into their stack.
- What can I build with the WoltSign API?
Your backend can create envelopes, assign signers, send signature requests, and track completion without anyone opening the WoltSign UI. Most teams use it to automate a recurring document flow: offer letters from an HRIS when a hire is confirmed, vendor agreements from an ERP when a purchase order is approved, or NDAs from a CRM when a deal reaches a certain stage. You can start from a template with two API calls or build a fully custom envelope with your own PDFs and fields.
- Do I have to use the WoltSign app if I integrate via API?
Not for sending. Most teams configure templates, folders, and workspace settings in the app once, then let the API handle every send. If you want to go fully programmatic, you can upload documents, place fields, assign signers, and send entirely from code.
- How does authentication work?
Server-side requests use an API key passed in the x-api-key header. You create keys under Integrations in the WoltSign app. Each request also identifies the workspace that owns the envelope or template. Keys should live in a secrets manager and never appear in browser code or source control.
- Does WoltSign support webhooks?
Yes. Configure an HTTPS endpoint in the WoltSign app and choose which envelope events should trigger a POST to your server: sent, signer viewed, signed, completed, declined, or voided. Your backend receives the event and can update a database row, trigger a notification, or advance a workflow step without polling the API.
- Where is the technical documentation?
At woltsign.com/documentation. It covers authentication, the full endpoint reference, webhook setup, and error handling. Each template in the app also generates a prefilled cURL example, the fastest way to see a real request for your specific template and workspace.
- Can I test my integration before it touches real signers?
Create a separate workspace for testing and use test email addresses for recipients. Build and verify your envelope flow there before pointing production triggers at live signers.
- What does the signer experience look like?
Once your backend sends an envelope, WoltSign emails each recipient a signing link. They open a browser-based signing session, complete any required fields, and sign. Your product does not need to handle any of this, but you can read the completed status via the API or webhook event once they are done. There is a full walkthrough at /help-center/what-signers-see.
Documentation
Everything you need to write your first request
Authentication, endpoint reference, workflow examples, and webhook setup are in the documentation hub. Open it when you are ready to move past capability browsing and into code.
For developers
Start with a template. Add automation when you are ready.
Sign up, connect your first template, and send a test envelope from your backend. Most integrations reach that point in a single afternoon.