Connect Fillout to ChatGPT: Manage Forms, Submissions, and Webhooks

If you need to connect Fillout to ChatGPT to orchestrate form lifecycles, extract nested submission data, or programmatically manage event webhooks, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Fillout's REST APIs. 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 Claude, check out our guide on connecting Fillout to Claude or explore our broader architectural overview on connecting Fillout to AI Agents.

Giving a Large Language Model (LLM) read and write access to a flexible form builder like Fillout is a massive engineering challenge. You have to handle dynamic form schemas, map custom question IDs to semantic fields, and deal with deeply nested response arrays. Every time a user adds a new question or logic jump in Fillout, your custom server code must be updated, redeployed, and tested.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Fillout, connect it natively to ChatGPT, and execute complex 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, implementing it against Fillout's highly dynamic API is exceptionally painful.

If you decide to build a custom MCP server for Fillout, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Fillout:

Dynamic Schemas and Abstract Question IDs

Unlike standard SaaS platforms with static endpoints (e.g., a /users endpoint returning a flat JSON object with first_name and email), a Fillout API surface is entirely defined by the user's custom form configuration. When you fetch a submission, you do not receive a clean key-value map. Instead, you receive an array of abstract question objects like {"id": "4aB9cE", "value": "John Doe"}.

To make sense of this data, your AI agent must first fetch the form metadata to map those abstract IDs back to human-readable question prompts. If your MCP server does not expose both the metadata and submission endpoints with strict relationship schemas, the LLM will hallucinate field mappings or fail to comprehend the data entirely.

Nested Submission Arrays and Calculation Data

Fillout forms support complex logic, including scoring, custom calculations, and URL parameters. When extracting a submission, the payload is deeply nested. A single response might contain a questions array, a calculations array, and a urlParameters array. Building static MCP schemas for this dynamic output requires writing a schema parser that understands how to flatten or navigate these nested arrays so the LLM can extract actionable insights without blowing out its context window.

Programmatic Webhook Management

When building agentic workflows, you often want your AI to subscribe to real-time events - like receiving a ping the moment a high-value prospect submits a form. Fillout requires you to register webhooks on a per-form basis. If you want to automate this, your MCP server must handle the precise URL validation and form ID mapping required by the POST /v1/api/forms/{formId}/webhooks endpoint. If the LLM passes an invalid payload structure, Fillout rejects the registration.

Fillout to ChatGPT Quickstart Guide

If you just want the fastest path from a fresh Truto account to ChatGPT calling the Fillout API, follow these steps. Truto handles the OAuth flows, API key management, and dynamic tool generation under the hood.

What you need:

• A Truto account with API access.
• A Fillout API key (generated from your Fillout developer settings).
• A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available.

Step 1: Connect Fillout to Truto

In the Truto dashboard, navigate to Integrated Accounts -> New Integrated Account, select Fillout, and input your API key. Truto securely vaults this credential. Make a note of your integrated_account_id.

Step 2: Generate the Fillout MCP Server

Truto creates MCP servers by deriving tool definitions directly from the upstream integration's resources. You can create this server via the Truto UI or programmatically via the API.

Option A: Via the Truto UI

1. Navigate to the integrated account page for your Fillout connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., allow read and write methods, filter by specific tags if needed).
5. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<secure_token>).

Option B: Via the API Make a single POST request to scope an MCP endpoint to that specific account. You can filter by methods and tags to constrain exactly what ChatGPT is allowed to do:

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Fillout for ChatGPT",
    "config": {
      "methods": ["read", "write"],
      "tags": ["forms", "submissions", "webhooks"]
    }
  }'

The response contains a url field. This single URL carries the routing instructions and cryptographic authentication required to execute tools. Treat it like a secret.

Step 3: Connect the MCP Server to ChatGPT

You can plug this URL into your AI framework in multiple ways.

Option A: Via the ChatGPT UI

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode.
3. Under MCP servers / Custom connectors, click Add new server.
4. Name it "Fillout API" and paste the Truto MCP URL into the Server URL field.
5. Click Save. ChatGPT will immediately handshake with the server and list the available Fillout tools.

Option B: Via Manual Config File (for local agents or Claude Desktop) If you are running a local testing framework or custom agent environment that requires a configuration file, you can wrap the Truto URL using the official Server-Sent Events (SSE) transport adapter:

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

Fillout Hero Tools for ChatGPT

Once connected, Truto dynamically exposes Fillout's endpoints as highly documented JSON-RPC tools. Here are the highest-leverage operations your AI agent can now perform.

List All Forms

Before an agent can query responses or set up webhooks, it needs to know which forms exist. This tool retrieves a paginated list of all forms in the connected Fillout workspace, returning critical identifiers like the internal id and the public formId.

Contextual usage: Agents should always call this first to discover available schemas before attempting to query submission data.

"List all the forms in my Fillout account and tell me the ID for the 'Customer Onboarding' form."

Get Single Form Metadata

This is the most critical tool for parsing Fillout data. It retrieves the complete structural blueprint of a specific form, including the questions array, calculations, and urlParameters.

Contextual usage: Because submissions only contain abstract question IDs, the LLM must call this tool to build a semantic mapping (e.g., mapping q_1A2b to "What is your company name?").

"Get the metadata for form ID 'abc123xyz'. I need to see the exact text of every question asked on this form."

List Form Submissions

Retrieves the actual responses submitted by users. By default, this tool fetches finished submissions and includes a submissionId for each entry.

Contextual usage: The agent will receive an array of answers. It should cross-reference these answers with the schema retrieved from the metadata tool to provide human-readable summaries.

"Fetch the latest 50 submissions for the 'Customer Onboarding' form. Tell me which companies have applied so far."

Get Single Submission

Allows the agent to drill down into a specific user's response. This is essential for workflows triggered by a webhook, where the agent only receives a submissionId and needs to pull the full payload.

Contextual usage: Use this when the agent needs to generate a dedicated report or summary for a single lead or ticket.

"Get the full submission details for submission ID 'sub_98765' on the 'Feedback' form and summarize their feature requests."

Create Form Submission

Allows the AI agent to programmatically insert data into a Fillout form as if a user had filled it out. This is useful for migrating data, testing workflows, or using Fillout as an internal data intake tool.

Contextual usage: The agent must construct a valid submissions array matching the required question IDs of the target form.

"Create a new submission for the 'Internal IT Request' form. Set the issue type to 'Hardware Request' and the urgency to 'High'."

Create Webhook

Automates the deployment of event subscriptions. The agent can configure a Fillout form to push data to an external URL whenever a new submission occurs.

Contextual usage: The agent must provide a valid formId and a target url.

"Create a webhook for the 'Sales Contact' form that points to 'https://hooks.myapp.com/fillout-ingest'."

For the complete tool inventory, including payload schemas and custom methods, view the Fillout integration page.

Workflows in Action

With the MCP server connected, ChatGPT can sequence these tools to solve complex operational problems without you having to write glue code.

Scenario 1: Lead Triage and Summarization

Marketing teams often struggle to quickly qualify complex form submissions. An AI agent can act as an automated SDR, fetching new leads, mapping the abstract data, and generating an executive summary.

"Check the 'Enterprise Demo Request' form for any submissions received today. Map the question IDs to the actual question text, and give me a summary of the 3 largest companies that applied, including their stated budget."

Step-by-step execution:

1. list_all_fillout_forms: The agent searches for the form named "Enterprise Demo Request" to get its id.
2. get_single_fillout_form_by_id: The agent fetches the form's metadata to learn that q_xyz means "Company Size" and q_abc means "Budget".
3. list_all_fillout_form_submissions: The agent pulls the recent submissions.
4. Synthesis: The LLM cross-references the submission arrays against the question map, identifies the largest companies, and prints a formatted executive summary for the user.

Scenario 2: Automated Event Subscriptions

DevOps or RevOps teams often need to pipe form data into external systems but hate navigating the UI to configure webhooks for every new campaign.

"Find the form named 'Q4 Webinar Registration' and set up a new webhook pointing to our Zapier catch hook URL at 'https://hooks.zapier.com/hooks/catch/123/abc'."

Step-by-step execution:

1. list_all_fillout_forms: The agent searches the workspace and retrieves the ID for the webinar form.
2. create_a_fillout_webhook: The agent executes the POST request, passing the form ID and the provided URL.
3. Result: The agent confirms the webhook was created and returns the new webhook's unique ID for auditing purposes.

Workflow Architecture

sequenceDiagram
    participant User as ChatGPT User
    participant GPT as ChatGPT (MCP Client)
    participant Server as Truto MCP Server
    participant Upstream as Fillout API

    User->>GPT: "Summarize recent submissions<br>for the Sales form."
    GPT->>Server: tools/call get_single_fillout_form_by_id
    Server->>Upstream: GET /v1/api/forms/{id}
    Upstream-->>Server: 200 OK (Form schema)
    Server-->>GPT: Return question metadata
    GPT->>Server: tools/call list_all_fillout_form_submissions
    Server->>Upstream: GET /v1/api/forms/{id}/submissions
    Upstream-->>Server: 200 OK (Response arrays)
    Server-->>GPT: Return raw submissions
    GPT-->>User: "Here is the summary based<br>on the mapped questions."

Security and Access Control

Exposing enterprise form data to an LLM requires strict governance. Truto's MCP architecture enforces security at the infrastructure layer, ensuring the model can only perform authorized actions.

• Method Filtering: When creating the MCP server, you can strictly limit the token to read operations. This guarantees the LLM can query form submissions but cannot accidentally delete responses or create rogue webhooks.
• Tag Filtering: By configuring tags: ["submissions"], you can scope the server to only expose tools related to viewing submissions, hiding administrative tools like form creation or webhook management from the agent entirely.
• Expiration Controls: For temporary tasks, you can append an expires_at timestamp when creating the server. Truto's infrastructure will automatically destroy the token and terminate access at the exact millisecond requested, leaving no stale credentials.
• Layered Authentication: By enabling require_api_token_auth, the Truto MCP URL demands a secondary layer of authentication. The caller must possess both the secure MCP URL and a valid Truto API bearer token, ensuring only authenticated team members can execute tool calls.
• Rate Limit Transparency: Truto acts as a transparent proxy. It does not retry, throttle, or apply backoff logic on rate limit errors. If Fillout returns an HTTP 429, Truto passes that error directly to the caller, normalizing the upstream rate limit information into standard IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The AI framework is responsible for handling its own retry and backoff strategies.

Stop Writing Integration Code

Building a custom MCP server for a dynamic API like Fillout is a massive distraction from your core product. You have to maintain schema parsers, handle pagination differences, manage OAuth tokens, and deal with nested payload normalization.

Truto abstracts this entire layer. We provide unified APIs and auto-generated MCP servers that turn complex upstream REST implementations into predictable, LLM-ready tools instantly.