MCP Server

The Formify MCP Server implements the Model Context Protocol — a standard that lets AI assistants connect to external services. With the Formify MCP server, AI assistants can securely access your Formify account to create and manage documents and drafts, inspect templates and fields, track signing progress, send reminders, and manage related account/webhook operations.

MCP server URL

https://mcp.formify.eu/mcp

Choose the right setup

How it works

The MCP server acts as a bridge between your AI client and the Formify API. OAuth authentication happens directly between your AI client and Formify's authorization server. The MCP server validates the token on each request and proxies tool calls to the Formify API. Each user authorizes access with their own Formify account.

OAuth with PKCE is the recommended connection method because the user signs in with Formify and the AI client does not need to store a long-lived secret. Some MCP clients cannot complete an OAuth flow yet and only allow you to paste a token or configure HTTP headers. For those clients, the Formify MCP server can also accept a Formify API key created in the Formify app and exchange it server-side for short-lived Bearer tokens before calling the API.

Quick start

Claude (Desktop & Web)

1. Go to Customize → Connectors → Add custom connector.
2. Enter the server URL: https://mcp.formify.eu/mcp
3. Click Add, then Connect.
4. Sign in to your Formify account and select Allow access.
5. Verify the connection by entering a prompt such as: "List my templates."

Claude Code (CLI)

1. Launch Claude Code in your terminal or VS Code extension.
2. Run /mcp add formify https://mcp.formify.eu/mcp
3. When prompted, complete the Formify login in your browser.
4. Verify with: "List the available Formify MCP tools."

Formify Claude Skills

Formify also provides a small set of Claude Skills that work well together with the MCP server. They give the assistant reusable guidance for common e-signing workflows, such as preparing documents, handling signer details, and choosing the right Formify MCP tools. See the skills on GitHub: formify-e-sign/formify-claude-skills.

Cursor, Windsurf, VS Code, Codex and other clients

Remote MCP configuration differs between clients and client versions. Use the server URL below and follow your client's own MCP configuration documentation:

https://mcp.formify.eu/mcp

AI clients without OAuth support

Some AI/MCP clients can't run the OAuth flow yet and only let you paste a static credential or configure HTTP headers. Use this path for clients such as Manus when OAuth is not available in the client's MCP setup. In that case, create a Formify API key such as sk_live_YOUR_API_KEY (or the same format with sk_test_ in test environments). The MCP server exchanges the API key for short-lived API access tokens and uses those for tool calls.

Create the API key in Formify

1. Sign in to app.formify.eu.
2. Open Settings and go to Integration.
3. Create a new API key. Choose a name that clearly describes where it will be used, such as Manus MCP or Team AI client.
4. Copy the generated key and store it securely. Treat it like a password.

Paste the API key as a token

1. Enter the server URL: https://mcp.formify.eu/mcp
2. Choose the client's API key or token authentication option if it asks for an auth type.
3. Paste the Formify API key value, for example sk_live_YOUR_API_KEY.
4. Verify the connection by asking the assistant to list your Formify templates or documents.

Custom headers

If your client only supports configuring raw HTTP headers, add the following header:

1. Enter the server URL: https://mcp.formify.eu/mcp
2. Open the client's custom HTTP headers configuration.
3. Add a header with:

   Header name:  Authorization
   Header value: Bearer sk_live_YOUR_API_KEY

4. Save the configuration and verify by asking the assistant to list your Formify templates or documents.

You can revoke this API key later in app.formify.eu → Settings → Integration. OAuth grants can be revoked from the same Integration area under My applications.

What you can do

Once connected, you can use natural language to manage the full document signing lifecycle:

• Send documents for signing — pick a template or upload your own PDF, fill in fields, add signers, and send
• Prepare drafts — create and edit drafts before sending, preview the PDF with signature fields, and send when ready
• Upload and merge PDFs — upload one or more PDF files, optionally merge them, and send for signing
• Track signing status — see who has signed and who hasn't
• Manage signees — send reminders, update contact details
• Handle document lifecycle — revoke, delete, or download completed documents
• Manage webhooks — set up real-time notifications for signing events

Example prompts

• "Send the NDA template to example.user@formify.eu for signing."
• "Upload this PDF and send it to Example User for signing."
• "Merge these two PDFs and send the combined document for signing."
• "List all documents waiting to be signed."
• "Has the contract with Example User been signed yet? If not, send a reminder."
• "Revoke the unsigned offer I sent yesterday."
• "Download the signed copy of the employment agreement."
• "Set up a webhook to notify me when documents are completed."

Available tools

Documents

Tool	Description
list_documents	List documents on the account
get_document	Get document status and signee details
create_document	Create a document from a template or uploaded PDF and send it for signing
revoke_document	Revoke an unsigned document
delete_document	Permanently delete a completed or revoked document
get_signed_document_url	Get a time-limited download link for a signed document (valid 10 minutes)
send_reminder	Send a signing reminder to unsigned signees
update_signee	Correct a signee's name, email, or phone number

Drafts

Tool	Description
list_drafts	List drafts with pagination
get_draft	Get full draft configuration
create_draft	Create a new draft
update_draft	Replace an existing draft's configuration
get_draft_file	Get the draft preview PDF as an embedded resource
get_draft_file_url	Get a one-time download URL for the draft preview PDF
send_draft	Convert a draft to a live document and send invitations
delete_draft	Permanently delete a draft

Files

Tool	Description
request_file_upload_url	Get a presigned upload URL for a PDF file attached to the conversation
upload_file	Upload a PDF by presigned upload ID, public URL, or base64 content
get_file_fields	List form fields in an uploaded PDF before creating a document
merge_files	Merge 2–8 uploaded PDFs into a single file (page order follows input order)
delete_file	Delete a previously uploaded file

Templates & form fields

Tool	Description
list_templates	List available signing templates
get_template	Get template details, signee slots, and signature settings
get_template_fields	List form fields in a template (types, options, editability)
get_document_fields	List form fields in a created document
get_document_field_values	Get current field values in a document
set_document_field_values	Update form field values on an existing document

Webhooks

Tool	Description
list_webhooks	List registered webhooks
register_webhook	Register a webhook for signing events
delete_webhook	Delete a webhook
rotate_webhook_secret	Rotate the HMAC signing secret for a webhook

Account & user

Tool	Description
get_account_users	List users on the account
get_account_capabilities	Check enabled features (BankID, WhatsApp, AI assistant, etc.)
get_current_user	Get the authenticated user's info

Authentication & permissions

The MCP server uses OAuth 2.0 with PKCE when the client supports it. No API keys or secrets are needed in that flow — just sign in to your Formify account when prompted.

For MCP clients that cannot run OAuth and only support a pasted token, you can use a Formify API key instead. This is a compatibility option for token-only clients. The MCP server does not call protected API endpoints directly with the API key; it exchanges the key for a short-lived Bearer access token and uses that token for Formify API requests.

When you connect, you authorize the AI client to perform actions on your behalf within your existing Formify account permissions:

• Documents — create, send, revoke, and delete documents; send reminders; update signee details
• Drafts — create, update, preview, send, and delete drafts
• Files — upload, merge, and delete PDF files
• Templates — browse and read templates and their form fields
• Webhooks — register, list, and delete webhooks
• Account — read account users, capabilities, and your own user profile

Depending on client support, authentication uses one of two credential paths plus the MCP session layer:

• OAuth tokens — The MCP client authenticates directly with Formify's authorization server. Access tokens are valid for 1 hour and refreshed automatically using a refresh token. Token refresh is handled entirely by the MCP client; the server accepts whatever valid Bearer token arrives on each request.
• API key fallback — If the client sends a Formify API key, the MCP server exchanges it with the Formify API for a short-lived Bearer token. The derived token is cached in process memory until it is close to expiry, keyed by a hash of the API key. The original API key is not written to disk by the MCP server.
• MCP server session — The server keeps an in-memory session per connected client. This session expires after 30 minutes of inactivity, independent of OAuth token lifetime. When a session expires, the client receives a 404 and must re-initialize the MCP connection — it does not need to re-authenticate with OAuth as long as the refresh token is still valid.

You can revoke access at any time in Settings → Integration. OAuth grants are managed under My applications; API keys are managed from the API key section in the same panel.

Privacy

The MCP server holds no persistent storage. During an active session, the OAuth access token or the short-lived access token derived from a Formify API key is kept in process memory to authenticate requests to the Formify API. Static API keys are used only for token exchange and are not persisted by the MCP server. When a PDF file is uploaded via the MCP server, the file is held temporarily in memory until it has been forwarded to the Formify API — typically a matter of seconds — and is then discarded. Draft preview PDFs fetched via get_draft_file follow the same pattern — held in memory for the duration of the request only, never persisted. No file data is written to disk or retained after the request completes.

The MCP server acts as a proxy: document metadata, form values and PDF previews transit through process memory only while a request is being fulfilled, are never written to disk, and are not retained afterwards. Full details in the Formify Privacy Policy.

Limitations

• AI responses may vary — always review tool results before confirming actions.
• PDF uploads are supported up to 50 MB. Files must not be password-protected or contain existing digital signatures.
• Rate limits apply: 60 requests per minute per session, 2 reminders per signee per hour.

Support