Connect Fillout to Claude: Control Form Metadata and Submissions

If your team needs to connect Fillout to Claude to automate form creation, extract submission data, or orchestrate dynamic webhook flows, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Fillout's REST API. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on /connect-fillout-to-chatgpt-manage-forms-submissions-and-webhooks/ or explore our broader architectural overview on /connect-fillout-to-ai-agents-automate-form-sync-and-response-flow/.

Giving a Large Language Model (LLM) read and write access to a dynamic form builder like Fillout is an engineering challenge. You have to handle API token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Fillout's specific field ID structures. Every time Fillout updates an endpoint or deprecates a field, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Fillout, connect it natively to Claude Desktop, and execute complex form management workflows using natural language.

The Engineering Reality of the Fillout API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against B2B APIs is painful. Fillout is built to handle complex, multi-page forms with branching logic. Its API reflects that complexity.

If you decide to build a custom Fillout MCP server, here are the specific integration challenges you will face:

Dynamic Submission Schemas

Unlike a traditional CRM where you POST a flat JSON object (e.g., {"first_name": "John"}), Fillout relies on dynamic question IDs. When you create a submission via the API, the payload requires an array of answers mapped to the exact internal string IDs of the form questions. An LLM cannot guess these IDs. Your MCP architecture must strictly enforce a two-step pattern: the agent must first pull the form metadata to discover the id of each question, and then construct the submission payload using those exact IDs. A managed MCP server exposes these constraints directly in the JSON Schema of the tools, guiding Claude to perform the lookup first.

Webhook Validation and Lifecycle Management

Automating webhooks via an LLM introduces severe security risks if not properly sandboxed. Fillout allows you to register webhook URLs to receive real-time updates on form submissions. If an LLM is given raw access to webhook creation, it might register unverified endpoints or accidentally delete mission-critical production webhooks. Your MCP server needs strict method filtering to ensure Claude can only read or manage webhooks within isolated testing environments, rather than mutating production hooks.

Rate Limit Realities

Fillout enforces strict rate limits on API requests, especially for bulk submission extraction. It is a common misconception that integration layers automatically absorb these limits. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Fillout API returns an HTTP 429 error, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit info into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. The caller - your MCP client or AI agent - is completely responsible for handling retry and backoff logic. Do not expect the MCP server to magically bypass upstream quota exhaustion.

Step 1: Generating the Managed MCP Server

Instead of writing and deploying a custom Node.js or Python server to translate JSON-RPC to HTTP, you can generate a secure MCP server URL for Fillout in seconds using Truto.

Each MCP server in Truto is scoped to a single integrated account (a specific authenticated connection to Fillout). The server URL contains a cryptographic token that encodes the authentication state, the allowed tools, and the expiration time.

There are two ways to generate this server.

Method 1: Via the Truto UI

For immediate testing and one-off workflows, generating the server via the UI is the fastest path.

1. Log into your Truto dashboard and navigate to the Integrated Accounts page.
2. Select your connected Fillout account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., read-only tools, specific tags, or an expiration date).
6. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/abc123def456...).

Method 2: Via the API

For production use cases - like programmatically provisioning MCP servers for your own end users - you should generate the server via the Truto REST API. This allows you to dynamically inject filters and short-lived expiry times.

Make an authenticated POST request to the /integrated-account/:id/mcp endpoint:

curl -X POST https://api.truto.one/integrated-account/<fillout_account_id>/mcp \
  -H "Authorization: Bearer <YOUR_TRUTO_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Fillout Automation Agent",
    "config": {
      "methods": ["read", "write"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API validates the configuration, ensures the Fillout integration has documented tools available, and returns a secure, hashed token URL. This URL is fully self-contained. The client requires no additional OAuth configuration.

Step 2: Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you need to register it with your client. We will cover the Claude Desktop approach and the generic configuration file approach.

Method 1: Via the Claude or ChatGPT UI

If you are using the desktop or web interfaces for these major models, connection is handled directly in the UI.

For Claude (Desktop or Web):

1. Open Claude and navigate to Settings -> Integrations -> Add MCP Server.
2. Paste your Truto MCP URL.
3. Click Add. Claude will immediately perform a handshake with the URL, fetch the tools/list, and load the Fillout capabilities into your active context.

For ChatGPT:

1. Open ChatGPT and go to Settings -> Connectors -> Add (or under Apps -> Advanced Settings -> Developer mode -> Custom connectors).
2. Name the connector "Fillout Operations".
3. Paste your Truto MCP URL in the Server URL field and click Save.

Method 2: Via Manual Configuration File

If you are running a custom LangChain agent, Cursor, or an automated Claude Desktop deployment, you can mount the server using the standard MCP JSON configuration file.

You will use the official Server-Sent Events (SSE) transport wrapper provided by the MCP project to map the remote Truto URL to local standard output.

Edit your claude_desktop_config.json (or equivalent client configuration) to include:

{
  "mcpServers": {
    "fillout-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/<YOUR_SECURE_TOKEN>"
      ]
    }
  }
}

Restart your client. The agent will initialize the SSE connection and pull down the schema definitions for the Fillout tools.

Hero Tools for Fillout

When the MCP client connects to Truto, it dynamically builds tool definitions based on the exact API schema. Here are the highest-leverage tools available for Fillout automation.

List All Fillout Forms

Tool name: list_all_fillout_forms

This tool retrieves all forms associated with the authenticated Fillout workspace. It returns critical metadata, including the internal id (used for API calls) and the formId (the public-facing identifier). This is always the starting point for any form automation, as the agent needs the specific form ID to act on submissions or webhooks.

"Claude, please list all the forms in my Fillout account. Find the one named 'Q3 Customer Feedback' and give me its internal ID."

Get Single Fillout Form by ID

Tool name: get_single_fillout_form_by_id

Once the agent has a form ID, it uses this tool to pull the deep metadata for that specific form. Crucially, this returns the questions array. Because Fillout requires submissions to map directly to question IDs (e.g., qst_9a8b7c), the agent must read this schema before attempting to push new data into the system.

"Get the metadata for form ID 'frm_123xyz'. Map out exactly what question IDs correspond to the 'Email Address' and 'NPS Score' fields."

List All Fillout Form Submissions

Tool name: list_all_fillout_form_submissions

This tool pulls the actual respondent data for a specific form. It handles Fillout's pagination automatically. If you configure it to return edit links (includeEditLink: true), the agent can retrieve URLs that allow users to update their specific submissions later.

"Pull all the finished submissions for the 'Q3 Customer Feedback' form. Summarize any submission where the NPS Score was lower than 6."

Create a Fillout Form Submission

Tool name: create_a_fillout_form_submission

This is a write-heavy tool that pushes new records into a Fillout form. It requires the form_id and a submissions array. The agent must format the payload precisely, mapping the target answers to the exact question IDs retrieved in earlier steps.

"I have a CSV of 5 legacy customer feedback responses. Format them into the correct JSON structure using the question IDs you found earlier, and create submissions for them in form 'frm_123xyz'."

Create a Fillout Webhook

Tool name: create_a_fillout_webhook

This tool registers a new webhook endpoint against a specific form. When new submissions occur, Fillout will push real-time event payloads to the provided URL. This allows an AI agent to wire up event-driven architecture purely through natural language.

"Create a webhook for the 'Support Intake' form that sends a POST request to 'https://api.mycompany.com/webhooks/fillout' whenever a new ticket is submitted."

For the complete tool inventory, including detailed JSON Schemas, parameter constraints, and webhook deletion methods, check the Fillout integration page.

Workflows in Action

With the MCP server connected, Claude can now execute complex, multi-step operations against Fillout without requiring you to write custom integration scripts. Here is how that looks in practice.

Workflow 1: Migrating Legacy Data into Fillout

Marketing teams often have historical survey data in spreadsheets that they want unified inside their active Fillout account for reporting purposes. Claude can handle the schema translation and ingestion.

"I need to import three old survey responses into the 'Annual NPS' form. First, figure out the form ID. Then, read the form's question schema so you know the correct field IDs for 'Email' and 'Rating'. Finally, use the create submission tool to insert these three records: alice@test.com (9), bob@test.com (5), charlie@test.com (10)."

Step-by-step execution:

1. Claude calls list_all_fillout_forms to find the ID for the "Annual NPS" form (e.g., frm_999).
2. Claude calls get_single_fillout_form_by_id passing frm_999. It reads the questions array in the response to determine that "Email" is qst_email and "Rating" is qst_rate.
3. Claude formats the data and calls create_a_fillout_form_submission with the payload:

   {
     "form_id": "frm_999",
     "submissions": [
       {
         "qst_email": "alice@test.com",
         "qst_rate": 9
       }
     ]
   }

The user gets immediate confirmation that the historical data has been successfully injected into the active form.

Workflow 2: Orchestrating Real-Time Data Syncs

DevOps and IT admins frequently need to connect newly created forms to internal event pipelines. Instead of clicking through the Fillout UI to manage webhooks, they can instruct the agent to do it programmatically.

sequenceDiagram
    participant Admin as IT Admin
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant Fillout as Fillout API

    Admin->>Claude: "Wire up the New Employee form to our Slack webhook."
    Claude->>MCP: Call list_all_fillout_forms()
    MCP->>Fillout: GET /v1/api/forms
    Fillout-->>MCP: Returns list of forms
    MCP-->>Claude: JSON array of forms
    Claude->>MCP: Call create_a_fillout_webhook(formId: "frm_hr123", url: "https://hooks.slack.com/...")
    MCP->>Fillout: POST /v1/api/forms/frm_hr123/webhooks
    Fillout-->>MCP: Webhook created (id: "hook_888")
    MCP-->>Claude: Success payload
    Claude-->>Admin: "Webhook successfully attached. The form will now post to Slack."

Security and Access Control

Giving an AI agent raw API access requires strict guardrails. Truto's MCP servers are designed with built-in access control mechanisms, allowing you to limit exactly what Claude can see and do.

• Method Filtering: You can restrict a server to specific operations. Setting config.methods: ["read"] ensures the server only exposes GET and LIST operations (like pulling form metadata). Tools like create_a_fillout_form_submission are stripped from the manifest entirely, preventing accidental data mutation.
• Tag Filtering: Integrations in Truto support resource tagging. You can configure an MCP server to only expose tools tagged with submissions, completely hiding administrative tools like webhook management from the LLM.
• Require API Token Auth: By default, possessing the MCP URL grants access. For higher security environments, setting require_api_token_auth: true forces the client to also pass a valid Truto API token in the headers, adding a secondary authentication layer.
• Automatic Expiration: You can set an expires_at timestamp when generating the server. Once the deadline passes, Truto automatically purges the server from the database and edge KV storage. This is ideal for granting an AI agent temporary access to complete a specific migration task.

Stop Writing Point-to-Point API Code

Building a custom MCP server for Fillout means writing boilerplate JSON-RPC handlers, mapping dynamic schemas, and managing token state. It forces your engineering team to absorb the maintenance cost of the Fillout API lifecycle.

By leveraging a managed MCP architecture, you shift that burden to the infrastructure layer. You get dynamic, documentation-driven tools that update instantly, strictly enforced security boundaries, and normalized rate limit tracking. This allows your team to focus on writing agent logic and complex workflows, rather than debugging HTTP requests.

If you are ready to give your AI agents secure, native access to Fillout and over a hundred other enterprise APIs, it is time to move to a managed MCP standard.