API vs MCP for e-signature: the difference and when to use which

Updated 19 November 2026

The short answer

  • An API connects your software to Formify. A developer writes code once, and your own system sends contracts for signature every time something happens, with no person involved.
  • MCP connects an AI assistant to Formify. You ask ChatGPT or Claude in plain language and the assistant picks the right step. Formify's tools tell it to ask you before it sends anything. No code.
  • The MCP server is built on the API. It sends your requests to the same Formify REST API, so both give you the same signature levels, the same sealed PDF and the same credits.
  • Use the API for fixed, repeated flows. Use MCP for the work that changes from day to day. Many teams use both: the API sends the standard agreement automatically, and people use the assistant for everything around it.
  • No developer and no chat? A form on your website or a Make scenario can send contracts on its own. See automated contract signing.

The paperwork behind the question

Most small and medium-sized businesses do not ask "API or MCP?" because they love technology. They ask because there is a pile of agreements that never gets sent on time: the engagement letter for a new client, the consultant NDA, the KYC form for a buyer.

There are two kinds of work in that pile. Some of it is the same every time: a new client registers, the same agreement goes out. Some of it is different every time: a contract that needs a clause changed, a signer who has not answered, three PDFs that should go out as one document. The API is built for the first kind. MCP is built for the second.

What is an API?

An API (application programming interface) is a fixed set of requests that one program can send to another. With the Formify REST API, your developer writes code that says, for example: upload this PDF, prefill these fields, send it to this person, and require passport and video selfie.

  • Who uses it: your software, written by a developer.
  • What triggers it: an event in your system, such as a new registration or an approved quote.
  • How it behaves: the same way every time. Nothing goes out unless the code says so.
  • How you know it is signed: a webhook. Formify notifies your system when a document is opened, signed or completed.

The Formify API uses JSON and OAuth 2.0, or an API key for tools that cannot use OAuth. The reference is published as OpenAPI, Markdown and llms.txt at developers.formify.eu. See API and webhooks.

What is MCP?

MCP (Model Context Protocol) is an open standard that lets an AI assistant use external services. An MCP server describes what a service can do as a list of tools. The assistant reads the list, chooses the tools that fit your request and calls them for you.

The Formify MCP server has 50 tools for documents, drafts, templates, signing links, form fields, reminders and webhooks. You connect it once, then ask:

  • "Send the consultant NDA to anna@example.com and require passport and video selfie."
  • "Has the engagement letter for the new client been signed? If not, send a reminder."
  • "Merge these two PDFs and send them as one document to the buyer and the seller."

You write a prompt instead of working in an editor. Ask for a draft first, and you can preview the PDF with the signature fields in place before it goes out.

  • Who uses it: a person, through ChatGPT, Claude or another AI assistant.
  • What triggers it: your request in the chat.
  • How it behaves: flexibly. The assistant decides which tools to use, so check what it has prepared before you let it send.

Server URL: https://mcp.formify.eu/mcp. Formify is also in ChatGPT's plugin directory. See the Formify MCP server.

API vs MCP: the differences at a glance

REST APIMCP server
ConnectsYour software to FormifyAn AI assistant to Formify
Who starts itAn event in your systemA person asking in plain language
Who decides the stepsYour developer, in codeThe assistant, from the tool list. You review and approve
Code neededYesNo
Best forFixed, repeated flows at volumeVaried, everyday tasks and one-off documents
Runs without a personYesNo, a person is in the chat
Sign-inOAuth 2.0 or an API key stored in your systemEach user signs in with their own Formify account (OAuth). API key only for clients without OAuth
Knowing when it is signedWebhooks to your systemAsk the assistant, or let it register a webhook for you
Signature levelsInk signature (SES), or passport and video selfie (AES)The same
CostCredits per signatureThe same credits. The MCP connection has no separate fee

MCP does not replace the API. It sits on top of it

The Formify MCP server is a bridge between your AI assistant and the Formify API. When you ask the assistant to send a contract, it calls an MCP tool, and the MCP server makes the matching API request with your own permissions. The MCP tools match the endpoints in the REST API, so what the assistant does can be built in code later.

In practice, that means three things:

  1. Nothing is lost by starting with MCP. What works in the chat today can be built into your system later, using the same API endpoints.
  2. The legal result is the same. A contract sent from Claude and a contract sent from your own system get the same signature level and the same PDF, sealed with a qualified certificate from a provider on the EU Trusted List.
  3. The assistant can set up parts of the API flow for you. For example, it can register a webhook so your system is notified when documents are completed, or allow your website to prefill a public signing link.

When to use the API

Choose the API when the same thing should happen every time, without anyone opening a chat.

  • A new client registers in your client portal, and the engagement letter goes out at once with their details filled in and locked.
  • A buyer registers with an estate agency, and the system sends the KYC form with passport and video selfie (AES).
  • A signed document is filed in your own system automatically when the webhook document.completed arrives.
  • Values must be trusted: a price, an approved amount or a start date that the signer must not change.

You need a developer. Use test keys (sk_test_) in test environments before you go live.

When to use MCP

Choose MCP when the work changes from case to case, or when the person doing it is not a developer.

  • A partner at an accounting firm sends a one-off agreement drafted in the chat, without opening another tool.
  • Someone in the office asks which contracts are still unsigned this week and reminds the people who have not signed.
  • A recruiter merges a cover letter and a contract into one PDF and sends it for signing.
  • A signer gave the wrong email address, and the assistant updates it and sends the invitation again.

You need ChatGPT with the Formify plugin, or an AI assistant that can add a remote MCP server: Claude, Claude Code, Cursor, Windsurf, VS Code, Codex or Manus.

Use both: one account, two ways in

You do not have to choose between the API and MCP. Both work on the same Formify account, with the same documents, templates (can be turned on with credits if you have Seats) and credits.

Example: an accounting firm. The client portal sends the engagement letter through the API when a new client signs up, and a webhook files the signed PDF. The rest of the week, the team uses Claude with the Formify MCP server: "Which engagement letters from last week are still unsigned? Remind those clients and tell me who they are."

Example: a developer building the integration. While writing the API code, the developer connects the MCP server in Claude Code or Cursor and tries each step in plain language first. The AI coding assistant can also read the API reference in llms.txt format.

Security: who can do what

  • API: your system holds the credentials. Store the API key or client secret like a password, and verify every webhook with its HMAC-SHA256 signature.
  • MCP: each user signs in with their own Formify account and gets access with their own permissions. With OAuth, the AI assistant does not need to store a long-lived secret. You can revoke ChatGPT's access in Formify under Settings, Integration, My applications.
  • Your data: you are the data controller, and Formify processes contract data as your processor. The AI service you connect handles what you write in the chat under your own agreement with that provider.

What it costs

There is no separate fee for the MCP connection. Documents use credits from your shared wallet, whichever way they are sent: 2 credits for a simple signature with ink (SES) and 8 credits for an advanced electronic signature (AES) with passport and video selfie.

Start free with 10 credits a month, top up from €10, or add Seats at €25 per seat per month with 100 credits each. Prices excl. VAT. See Pricing.

Frequently asked questions

What is the difference between an API and MCP?

An API lets one program talk to another with fixed requests that a developer writes in code. MCP (Model Context Protocol) lets an AI assistant such as ChatGPT or Claude use a service by choosing from a list of tools, based on what you ask in plain language. With Formify, the API connects your software, and the MCP server connects your AI assistant.

Does MCP replace the API?

No. The Formify MCP server is built on the Formify REST API, and its tools match the endpoints of the API. MCP makes the API usable from an AI assistant. Fixed, automated flows still run best through the API.

Should I use the API or the MCP server for e-signing?

Use the API when the same agreement should go out automatically every time something happens in your system. Use the MCP server when people send, check and follow up on contracts in varied ways and want to do it from ChatGPT or Claude without code. Many businesses use both on the same account.

Which one needs a developer, the API or MCP?

The API does. The MCP server does not: you install Formify from ChatGPT's plugin directory, or add the server URL https://mcp.formify.eu/mcp to your AI assistant, and sign in with your Formify account.

Can an AI assistant send a contract for signature without me confirming?

Not by design. Formify's MCP tools tell the assistant to ask you before it sends a document, and you can ask for a draft to preview the PDF with the signature fields first. How your AI client asks for approval depends on the client. The assistant works only with your own Formify permissions. For fully automatic sending without a person, use the API.

Do the API and the MCP server give the same signature level?

Yes. Both use the same signing flow. A simple signature with ink is a simple electronic signature (SES), and a signature with passport and video selfie is an advanced electronic signature (AES) under eIDAS. Every signed PDF is sealed with a qualified certificate from a provider on the EU Trusted List.

Does MCP cost more than the API?

No. The MCP connection has no separate fee. Both use the same credits from your shared wallet: 2 for a simple signature with ink, 8 with passport and video selfie. You get 10 free credits a month. Top up from €10, or add Seats at €25 per seat per month with 100 credits each. Prices excl. VAT.

Can I start with MCP and move to the API later?

Yes. The MCP tools match the endpoints of the Formify REST API, so what works in the chat can be built into your own system later, on the same account with the same documents and credits.

Try both on one free account

Connect the MCP server and send your first contract from the chat today. When you are ready to build it into your own system, the same account works with the API.