For developers

Build contract workflows with Formable DevTools

APIs and a drop-in frontend for your product.

// Create a request, then embed signingUrl in an iframe.const response = await fetch(API_URL, {    method: "POST",    headers: {      Authorization: `Bearer ${apiKey}`,      "Content-Type": "application/json",    },    body: JSON.stringify({      templateId: "tmpl_nda_v3",      signer: { email: "jane@acme.com" },    }),  },);const { signingUrl } = await response.json();

response = requests.post(API_URL,  headers={    "Authorization": f"Bearer {api_key}",    "Content-Type": "application/json",  },  json={    "templateId": "tmpl_nda_v3",    "signer": { "email": "jane@acme.com" },  },)signing_url = response.json()["signingUrl"]

/*Create a signature request.The JSON body includes signingUrl for the iframe.*/req, _ := http.NewRequest(  "POST",  apiURL,  bytes.NewBuffer(body),)req.Header.Set("Authorization", "Bearer "+apiKey)resp, _ := http.DefaultClient.Do(req)

response = Faraday.post(API_URL,  headers: {    "Authorization" => "Bearer #{api_key}",    "Content-Type" => "application/json"  },  json: {    templateId: "tmpl_nda_v3",    signer: { email: "jane@acme.com" }  })

/** * POST creates the signature request. * Read signingUrl from the response and set it as the iframe src. */HttpRequest request = HttpRequest.newBuilder()  .uri(URI.create(API_URL))  .header("Authorization", "Bearer " + apiKey)  .POST(BodyPublishers.ofString(body))  .build();

/** * Create a signature request. * $response['signingUrl'] is the iframe src. */$response = $client->post($apiUrl,  [    'headers' => [      'Authorization' => "Bearer $apiKey",      'Content-Type' => 'application/json'    ],    'json' => [      'templateId' => 'tmpl_nda_v3',      'signer' => ['email' => 'jane@acme.com']    ]  ]);

// Create a request, then embed signingUrl in an iframe.const response = await fetch(API_URL, {    method: "POST",    headers: {      Authorization: `Bearer ${apiKey}`,      "Content-Type": "application/json",    },    body: JSON.stringify({      templateId: "tmpl_nda_v3",      signer: { email: "jane@acme.com" },    }),  },);const { signingUrl } = await response.json();

response = requests.post(API_URL,  headers={    "Authorization": f"Bearer {api_key}",    "Content-Type": "application/json",  },  json={    "templateId": "tmpl_nda_v3",    "signer": { "email": "jane@acme.com" },  },)signing_url = response.json()["signingUrl"]

/*Create a signature request.The JSON body includes signingUrl for the iframe.*/req, _ := http.NewRequest(  "POST",  apiURL,  bytes.NewBuffer(body),)req.Header.Set("Authorization", "Bearer "+apiKey)resp, _ := http.DefaultClient.Do(req)

response = Faraday.post(API_URL,  headers: {    "Authorization" => "Bearer #{api_key}",    "Content-Type" => "application/json"  },  json: {    templateId: "tmpl_nda_v3",    signer: { email: "jane@acme.com" }  })

/** * POST creates the signature request. * Read signingUrl from the response and set it as the iframe src. */HttpRequest request = HttpRequest.newBuilder()  .uri(URI.create(API_URL))  .header("Authorization", "Bearer " + apiKey)  .POST(BodyPublishers.ofString(body))  .build();

/** * Create a signature request. * $response['signingUrl'] is the iframe src. */$response = $client->post($apiUrl,  [    'headers' => [      'Authorization' => "Bearer $apiKey",      'Content-Type' => 'application/json'    ],    'json' => [      'templateId' => 'tmpl_nda_v3',      'signer' => ['email' => 'jane@acme.com']    ]  ]);

Build Formable e-signing APIs for Virtual Data Rooms, HR Onboarding, Virtual Staffing, Construction OS, Digital Mortgage, EOR Platforms, Transaction Platforms, Vendor Onboarding, Legal Ops, Lease Platforms, Investor Onboarding, Sales CPQ, Fund Admin, Procurement Software, Insurance Platforms, eConsent Platforms

Use the Formable API to embed e-signing in these platforms: Virtual Data Rooms, HR Onboarding, Virtual Staffing, Construction OS, Digital Mortgage, EOR Platforms, Transaction Platforms, Vendor Onboarding, Legal Ops, Lease Platforms, Investor Onboarding, Sales CPQ, Fund Admin, Procurement Software, Insurance Platforms, eConsent Platforms.

Virtual Data Rooms
HR Onboarding
Virtual Staffing
Construction OS
Digital Mortgage
EOR Platforms
Transaction Platforms
Vendor Onboarding
Legal Ops
Lease Platforms
Investor Onboarding
Sales CPQ
Fund Admin
Procurement Software
Insurance Platforms
eConsent Platforms

Virtual Data RoomsHR OnboardingVirtual StaffingConstruction OSDigital MortgageEOR PlatformsTransaction PlatformsVendor OnboardingLegal OpsLease PlatformsInvestor OnboardingSales CPQFund AdminProcurement SoftwareInsurance PlatformseConsent PlatformsVirtual Data RoomsHR OnboardingVirtual StaffingConstruction OSDigital MortgageEOR PlatformsTransaction PlatformsVendor OnboardingLegal OpsLease PlatformsInvestor OnboardingSales CPQFund AdminProcurement SoftwareInsurance PlatformseConsent Platforms

Integrate e-signing with just a couple lines of code

Request a signing session and Formable returns a URL you can embed directly in your product.

The Formable embedded signing API accepts a template ID and recipient list via a single REST call and returns a SignatureRequestUrl you can render in an iframe. No redirects, no separate authentication flow for signers. Works with any backend: Node.js, Python, Go, Ruby, Java, and PHP examples are available in the documentation. Webhook events notify your server when recipients view, complete, or decline a document.

Explore Signing API

/** * Create the request, then mint a signing URL. * The URL is short-lived. Embed it in an iframe on the client. */export const createSigningUrl = async () => {  const created = await fetch(    "https://api.formabledocs.com/api/v0/signature-requests",    {      method: "POST",      headers: {        Authorization: `Bearer ${apiKey}`,        "Content-Type": "application/json",      },      body: JSON.stringify({        templateId: "tmpl_offer_v1",        signer: { email: "jane@acme.com", name: "Jane Doe" },        sender: { email: "alex@acme.com", name: "Alex Chen" },      }),    },  );  const { id } = await created.json();  // POST /url mints the embeddable link  const minted = await fetch(    `https://api.formabledocs.com/api/v0/signature-requests/${id}/url`,    {      method: "POST",      headers: { Authorization: `Bearer ${apiKey}` },    },  );  const { signingUrl } = await minted.json();  return signingUrl;};

import { useEffect, useState } from "react";import { createSigningUrl } from "./createSigningUrl";export const SigningEmbed = () => {  const [signingUrl, setSigningUrl] = useState<string | null>(null);  useEffect(() => {    createSigningUrl().then(setSigningUrl);  }, []);  if (!signingUrl) {    return null;  }  return (    <iframe      src={signingUrl}      title="Sign document"    />  );};

/** * Create the request, then mint a signing URL. * The URL is short-lived. Embed it in an iframe on the client. */export const createSigningUrl = async () => { const created = await fetch( "https://api.formabledocs.com/api/v0/signature-requests", { method: "POST", headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json", }, body: JSON.stringify({ templateId: "tmpl_offer_v1", signer: { email: "jane@acme.com", name: "Jane Doe" }, sender: { email: "alex@acme.com", name: "Alex Chen" }, }), }, ); const { id } = await created.json(); // POST /url mints the embeddable link const minted = await fetch( `https://api.formabledocs.com/api/v0/signature-requests/${id}/url`, { method: "POST", headers: { Authorization: `Bearer ${apiKey}` }, }, ); const { signingUrl } = await minted.json(); return signingUrl;};

Document redlining on your software

Not every contract is ready to sign. Formable is the only e-signing API with a unified redlining editor.

Formable redlining is a two-party negotiation on a DOCX before anyone signs. The contract owner starts the redline request and mints a RedlineUrl. The signing party proposes changes to the terms on their turn. The contract owner reconciles those negotiated redlines by accepting or rejecting them. When the owner is done, the same document is ready for signing and continues into Formable's embedded e-signing flow.

Start: the contract owner creates a redline request The contract owner is the party that originates the contract. They upload a DOCX and the two-party list to the Formable redlining API. Formable creates a redline request and returns a RedlineUrl to embed in an iframe. That URL opens the unified redlining editor on the owner's first turn, with the initial contract terms.
Signing party turn: propose changes to the terms The signing party is the counterparty. On their turn they open the same RedlineUrl and edit the document. They propose new or revised terms as tracked changes, and can leave comments. When they submit, the turn passes back to the contract owner with those negotiated redlines waiting for review.
Contract owner turn: reconcile negotiated redlines The contract owner reviews each proposed redline and accepts or rejects it. That accept-or-reject pass is how Formable reconciles the negotiation: agreed language stays, rejected language does not. The owner can make further edits and send another signing-party turn, or keep cycling until the remaining terms are settled.
Done: the document is ready for signing When tracked changes are resolved and the contract owner has no further revisions, the document is ready for signing. If heavy editing moved the layout, the owner can confirm signature field placement, then the same document continues into the embedded signing flow so both parties can sign without leaving your product. Webhooks notify your server as parties view, revise, and complete the request.

Explore Redlining API

Start
Redline request createdContract owner
Mint a RedlineUrlUpload a DOCX and embed the editor
Signing party turn
Changes proposedSigning party
Contract owner turn
Revisions reviewedContract owner
Done
Ready for signingContract owner
Same documentMoves into the signing flow

Production-ready from day one

Formable developer APIs include white-label branding for embedded e-signing emails and editors, document security with encryption, access controls, and a sealed audit trail on every envelope, plus webhook events for document.viewed, document.signed, and document.completed so your backend can react as recipients progress through signature requests.

White-labeling
Apply your colors, email subject, and CTAs across embedded signing.
Talk to us
Document security
Encryption, access controls, and a sealed audit trail on every envelope.
Learn about security
app.formabledocs.com
Signed copy
Master services agreement
Acme Labs ↔ Northwind Partners
Maya ChenSigned Mar 12
Audit trail
Envelope sentMatt · 2d ago
Document viewedMaya · 2h ago
Document signedMaya · 1h ago
Audit trail sealedFormable · Just now

Signing webhooks

Receive events when documents are viewed, signed, completed, and more.

Read the docs

webhooks.ts

app.post("/webhooks/formable", async (req, res) => {  const event = req.body;  // Verify Formable-Signature before trusting the payload  if (event.type === "document.viewed") {    await trackView(event.data.envelopeId);  }  if (event.type === "document.signed") {    await notifySender(event.data);  }  if (event.type === "document.completed") {    await fulfillOrder(event.data.envelopeId);  }  res.status(200).end();});

Frequently asked questions

Where are the Formable API docs for humans and agents?

Human guides and API reference are at docs.formabledocs.com. Agents should start from the LLM developer prompt and the live OpenAPI specs for v1 and v0.

Do I need to build a signing UI?

No. One API call returns a signing URL you embed in an iframe. Formable renders the signing experience.

Does Formable have language-native SDKs?

Yes. Formable publishes language-native SDKs for Node.js, Python, PHP, Java, Go, Ruby, .NET. Node.js: npm: npm install formable-node; yarn: yarn add formable-node; pnpm: pnpm add formable-node; bun: bun add formable-node Python: pip: pip install formable-sdk PHP: Composer: composer require formable/formable-sdk Java: Gradle: implementation 'com.formabledocs:formable-sdk'; Maven: mvn dependency:get -Dartifact=com.formabledocs:formable-sdk Go: go: go get github.com/FormableDocs/formable-go Ruby: gem: gem install formable; bundler: bundle add formable .NET: dotnet: dotnet add package Formable. Guides are at docs.formabledocs.com/sdks/overview.

How do the two parties redline a contract in Formable?

The contract owner starts a redline request and embeds a RedlineUrl. The signing party proposes tracked changes to the terms. The owner reconciles those negotiated redlines by accepting or rejecting them, and turns can repeat until the owner marks the document ready for signing. The same file then moves into embedded e-signing.

What products does the Formable API cover?

Embedded e-signing and embedded redlining. Both return short-lived URLs for iframe embed, with webhooks and test mode.

How do I embed e-signing in my product with Formable?

Create an API key, create a signature request with the REST API or an SDK, then embed the returned signing URL in an iframe. Recipients review and sign inside your product—no redirect and no custom signing UI to build. Follow the walkthrough at docs.formabledocs.com.

Didn't find an answer to your question? Book a short call and we'll walk through the Formable API with you.

Book a call

Human readable, agent ready

We know you're not coding manually anymore. Our docs are structured in OpenAPI so your agents can begin implementing with minimal prompting.

Formable publishes an OpenAPI 3.0 specification covering all REST endpoints for signature requests, template management, recipients, and webhook configuration. The spec is machine-readable and compatible with tools like Swagger UI, Postman, and AI coding assistants. Every request parameter, response schema, and error code is described so developers can integrate without guesswork.

A spec humans can browse

Start here to learn about how Formable's API works from a high level.

Search...⌘KSupportDashboard

GuidesAPI Reference

Getting Started

Core concepts

The key objects and terms you'll work with when embedding e-signatures.

For e-signatures, you upload a reusable template, create a signature request with one or more signers, mint a signing URL per recipient, then download the signed envelope when they're done.

Templates

A template is a PDF, DOC, or DOCX with fields placed on it. Upload once, then create many signature requests from the same templateId.

Read the docs

A spec agents can implement

We've used this prompt with Claude, Cursor, Codex, and Gemini. Each integrated Formable in one shot.

Open prompt

Language-native SDKs

Install the official Formable developer client in your project language today

Formable publishes language-native SDKs for Node.js, Python, PHP, Java, Go, Ruby, .NET. Install commands: Node.js: npm: npm install formable-node; yarn: yarn add formable-node; pnpm: pnpm add formable-node; bun: bun add formable-node Python: pip: pip install formable-sdk PHP: Composer: composer require formable/formable-sdk Java: Gradle: implementation 'com.formabledocs:formable-sdk'; Maven: mvn dependency:get -Dartifact=com.formabledocs:formable-sdk Go: go: go get github.com/FormableDocs/formable-go Ruby: gem: gem install formable; bundler: bundle add formable .NET: dotnet: dotnet add package Formable. Each SDK wraps the Formable REST API with typed requests and responses for templates, embedded signing, redlining, billing, and health checks.

Explore SDK docs

npmyarnpnpmbun

npm install formable-node

yarn add formable-node

pnpm add formable-node

bun add formable-node

pip

pip install formable-sdk

Composer

composer require formable/formable-sdk

GradleMaven

implementation 'com.formabledocs:formable-sdk'

mvn dependency:get -Dartifact=com.formabledocs:formable-sdk

go get github.com/FormableDocs/formable-go

gembundler

gem install formable

bundle add formable

dotnet

dotnet add package Formable

Have a deadline to meet on a project?

Book a demo and we'll show you how we can help

Book a demo View documentation