Adobe Acrobat Sign → Embedded signing

This guide helps you move an Adobe Acrobat Sign embedded signing integration to Formable. You still create a send, mint a signing URL, embed it, and download the completed PDF. You drop OAuth, regional hosts, transient documents on every send, and OUT_FOR_SIGNATURE polling in favor of Bearer API keys, template-first sends, and webhook- or poll-driven completion. If you also prepare library documents or authoring views inside your product, migrate that first with Adobe Acrobat Sign → Embedded templates. Formable signing always starts from a prepared template.

New to Formable? Complete the Embedded signing walkthrough first, then use this page as a translation layer from Acrobat Sign agreements and signing URLs.

Prefer a white-glove migration? Email matt@formabledocs.com and we’ll handle moving your Adobe Acrobat Sign integration to the Formable API.

What you’re moving

In Adobe Acrobat Sign you typically:

Authenticate with OAuth (and often x-api-user / on-behalf-of headers) against a regional host such as api.na1.adobesign.com
Upload a transient document, or reference a library document
POST /agreements with participantSetsInfo and state: "IN_PROCESS"
Poll until the agreement is OUT_FOR_SIGNATURE, then call GET /agreements/{agreementId}/signingUrls (or POST .../views with a SIGNING view)
Embed or redirect to the signing URL, detect completion via webhooks or status polling, then download the combined PDF

In Formable you:

Authenticate with a Bearer API key (fmbl_…)
Create an embedded signature request from a templateId with a signers array (each with email, name, and role)
Mint a signingUrl from each signer’s recipientSignatureId (no transient document, no regional host, no status wait)
Load it in a plain iframe (URL lasts 1 hour)
Handle document_completed or poll status, then download the signed envelope

The product journey stays the same: prepare a document, send it, embed signing, react when done. The API surface is smaller and organization-scoped by the key.

Recommended order of work

Get a Formable API key

Create an organization and key in Settings. See Authentication. You do not need OAuth token exchange for the standard integration.

Migrate templates and field IDs

Re-upload documents and place fields in Formable. If you embed library authoring, follow Embedded templates migration.

Replace POST /agreements

Map participants and merge fields to signers, sender, and optional fields.

Replace signingUrls / SIGNING views

Call create signing URL; drop regional hosts and OUT_FOR_SIGNATURE polling.

Swap Acrobat Sign webhooks for Formable webhooks

What’s similar

Several Acrobat Sign ideas transfer directly:

A reusable library document / template still backs many sends.
You still create a send unit (agreement → signature request), then open a short-lived URL for the signer.
Prefill / merge values still happen at send time; Formable uses fields: [{ fieldId, value }].
Sandbox / non-production traffic maps to testMode: true. Test mode documents are watermarked and are not legally binding.
After completion you still fetch a combined signed PDF.

If your Acrobat Sign flow is “create agreement → get signing URL → iframe → webhook → download,” you are remapping objects and removing transient-document and regional-host bookkeeping, not redesigning the user journey.

What’s different

These Acrobat Sign-specific pieces do not carry over:

Area	Adobe Acrobat Sign	Formable
Auth	OAuth access token; often `x-api-user`	Bearer `fmbl_…`; no acting-as headers
Base URL	Regional (`api.na1.adobesign.com`, etc.)	`https://api.formabledocs.com`
Files on send	Transient document or library document on create	Upload a template first, then send with `templateId`
Ready-to-sign	Poll until `OUT_FOR_SIGNATURE` before signing URLs	Create the request, then mint the URL when ready
Signing URL	`GET .../signingUrls` or `POST .../views` (`SIGNING`)	`POST /v1/recipient-signatures/{id}/url`
Completion UX	Redirect / return URL options on some views	`onSigningComplete` iframe message for UI; confirm with webhooks or polling
View TTL	Short-lived signing URLs	1 hour
Webhooks	Acrobat Sign webhook subscriptions + event names	Org-level URL, `Content-Sha256`
Participants	`participantSetsInfo` with `order` / `role`	`signers[]` with `email`, `name`, and `role`

You no longer upload a transient document per send or wait for Acrobat Sign’s async agreement state machine. Create the request when you’re ready to send, mint the URL when the user is ready to sign, and listen for completion out of band.

Concept map

Adobe Acrobat Sign	Formable	Notes
OAuth access token	API key (`Authorization: Bearer fmbl_…`)	No OAuth for the standard integration.
Account / `x-api-user`	Organization	Implied by the API key.
Agreement	Signature request	Formable’s send unit.
Participant set member	`signers[]` with `email`, `name`, and `role`	Embedded by default once you mint a `signingUrl`. Save each `recipientSignatureId`.
Library document	Template	Prepared once; reused via `templateId`.
Transient document	Template upload	Do not re-upload on every send.
Signing URL	`signingUrl`	Expires after 1 hour.
`AGREEMENT_WORKFLOW_COMPLETED` / similar	`document_completed` / status `Completed`	Then fetch the signed PDF.
Combined document	Signed envelope	Presigned PDF download URL.

Endpoint map

Adobe Acrobat Sign	Formable
`POST /api/rest/v6/transientDocuments` + `POST /agreements`	Upload a template, then `POST /v1/signature-requests/embedded`
`POST /agreements` with `libraryDocumentId`	`POST /v1/signature-requests/embedded` with `templateId`
`GET /agreements/{id}/signingUrls`	`POST /v1/recipient-signatures/{id}/url`
`POST /agreements/{id}/views` (`SIGNING`)	`POST /v1/recipient-signatures/{id}/url`
`GET /agreements/{id}/combinedDocument`	`GET /v1/signature-requests/{id}/signed-envelope`
Webhook subscriptions	Webhook URL in Settings

Auth

Acrobat Sign:

Authorization: Bearer {access_token}

against a regional host such as https://api.na1.adobesign.com/api/rest/v6/..., often with x-api-user. Formable:

curl https://api.formabledocs.com/v1/signature-requests \
  --header "Authorization: Bearer fmbl_YOUR_API_KEY"

One global API host. No x-api-user. Create the key in Settings and keep it on the server. Full details: Authentication.

Migrate the flow

1. Create the signature request (was: create agreement)

Adobe Acrobat Sign (simplified, from a library document):

{
  "fileInfos": [
    {
      "libraryDocumentId": "ADOBE_LIBRARY_DOCUMENT_ID"
    }
  ],
  "name": "Customer Agreement",
  "participantSetsInfo": [
    {
      "memberInfos": [{ "email": "jane@example.com" }],
      "order": 1,
      "role": "SIGNER"
    }
  ],
  "signatureType": "ESIGN",
  "state": "IN_PROCESS",
  "mergeFieldInfo": [
    { "fieldName": "company", "defaultValue": "Acme Corporation" }
  ]
}

Formable:

curl --request POST \
  --url https://api.formabledocs.com/v1/signature-requests/embedded \
  --header "Authorization: Bearer $TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{
    "templateId": "abc123xyz",
    "signers": [
      { "email": "jane@example.com", "name": "Jane Doe", "role": "SIGNER" }
    ],
    "sender": { "email": "you@yourcompany.com", "name": "Your Company" },
    "fields": [
      { "fieldId": "field_company_name", "value": "Acme Corporation" }
    ],
    "testMode": true
  }'

Response

{
  "signatureRequestId": "sr_456def",
  "signers": [
    {
      "email": "jane@example.com",
      "name": "Jane Doe",
      "recipientSignatureId": "rsig_789ghi"
    }
  ]
}

Pass a signers array on every create. Each signer needs email, name, and role. sender is optional and defaults to the org owner. Map merge field names to Formable fieldIds from the template editor (not Acrobat Sign fieldNames). Save each signer’s recipientSignatureId to mint their signing URL.

Adobe Acrobat Sign	Formable
`libraryDocumentId`	`templateId`
`transientDocumentId` on create	Upload a template first; do not attach files on send
`participantSetsInfo[].memberInfos[].email`	`signers[].email` / `name`
`order` / `role`	`signers[].role` (signing order follows the array)
`mergeFieldInfo`	`fields: [{ fieldId, value }]`
`state: "IN_PROCESS"`	Create, then mint the URL when ready
Sandbox / non-billing testing	`testMode: true` (watermarked, not legally binding)

2. Create the signing URL (was: signingUrls / SIGNING view)

Adobe Acrobat Sign:

GET /api/rest/v6/agreements/{agreementId}/signingUrls

Often after polling GET /agreements/{agreementId} until status is OUT_FOR_SIGNATURE. Formable:

curl --request POST \
  --url https://api.formabledocs.com/v1/recipient-signatures/rsig_789ghi/url \
  --header "Authorization: Bearer $TOKEN"

Response

{
  "signingUrl": "https://app.formabledocs.com/sign/embedded/xyz789abc",
  "expiresAt": "2024-01-16T10:30:00.000Z"
}

No regional host, no OUT_FOR_SIGNATURE wait, and no separate views payload. Formable URLs last 1 hour. Creating a URL for an already completed request returns 409.

3. Embed on the client

<iframe
  src="https://app.formabledocs.com/sign/embedded/xyz789abc"
  width="100%"
  height="800"
  allow="fullscreen"
  style="border: none;"
></iframe>

window.addEventListener("message", (event) => {
  if (event.origin !== "https://app.formabledocs.com") return;
  if (!event.data || typeof event.data !== "object") return;

  if (event.data.type === "onSigningComplete") {
    // signer finished — close the iframe or show success
  }
});

Use onSigningComplete for client UX instead of relying only on a return / redirect URL. Confirm completion with document_completed or by polling status until Completed before downloading. See Embedded signing.

4. Download the signed PDF

curl --request GET \
  --url https://api.formabledocs.com/v1/signature-requests/sr_456def/signed-envelope \
  --header "Authorization: Bearer $TOKEN"

Response

{
  "signedEnvelopePresignedUrl": "https://s3.amazonaws.com/bucket/signed-envelope.pdf?..."
}

Webhook verification uses Content-Sha256. See Verifying webhooks and Webhooks overview.

Differences to plan for

API keys instead of OAuth

Drop OAuth token exchange and x-api-user headers for a Bearer API key on your server. The organization is implied by the key.

Template-first, not transient-document-on-send

Acrobat Sign often uploads a transient document per agreement. Formable expects a prepared template first. Upload once, place fields, then send with templateId.

No OUT_FOR_SIGNATURE polling

You do not wait for an async agreement state before minting a signing URL. Create the signature request, then call create signing URL when the signer is ready.

One global API host

Drop regional base URL discovery (api.na1, api.eu1, and similar). All Formable calls go to https://api.formabledocs.com.

iframe postMessage instead of return URL alone

Listen for onSigningComplete to update the client immediately. Confirm with a webhook or poll before downloading, then build any “signing finished” screen in your own app.

Checklist

Create a Formable API key

In Settings.

Prepare templates and field IDs

Or migrate the embedded template flow separately.

Replace POST /agreements

Use create embedded signature request with signers (including role), optional sender, and optional fields.

Replace signingUrls / SIGNING views

Call create signing URL with each signer’s recipientSignatureId; drop regional hosts and OUT_FOR_SIGNATURE polling.

Swap Acrobat Sign webhooks for Formable webhooks

Handle document_completed and download the signed envelope.

Next steps

Embedded templates migration

Map library documents and authoring views to Formable.

Embedded signing walkthrough

Full Formable signing walkthrough.

Webhooks

Authentication

Bearer fmbl_ API keys.

Getting Started

Walkthroughs

SDKs

Migrations

Webhooks

Adobe Acrobat Sign → Embedded signing

What you’re moving

Recommended order of work

What’s similar

What’s different

Concept map

Endpoint map

Auth

Migrate the flow

1. Create the signature request (was: create agreement)

2. Create the signing URL (was: signingUrls / SIGNING view)

3. Embed on the client

4. Download the signed PDF

Differences to plan for

Checklist

Next steps

Embedded templates migration

Embedded signing walkthrough

Webhooks

Authentication

​What you’re moving

​Recommended order of work

​What’s similar

​What’s different

​Concept map

​Endpoint map

​Auth

​Migrate the flow

​1. Create the signature request (was: create agreement)

​2. Create the signing URL (was: signingUrls / SIGNING view)

​3. Embed on the client

​4. Download the signed PDF

​Differences to plan for

​Checklist

​Next steps

Embedded templates migration

Embedded signing walkthrough

Webhooks

Authentication

What you’re moving

Recommended order of work

What’s similar

What’s different

Concept map

Endpoint map

Auth

Migrate the flow

1. Create the signature request (was: create agreement)

2. Create the signing URL (was: signingUrls / SIGNING view)

3. Embed on the client

4. Download the signed PDF

Differences to plan for

Checklist

Next steps