Connect Penneo to ChatGPT: Sync Forms and Submission Data via MCP

If you need to connect Penneo to ChatGPT to automate document signing, extract KYC answers, or manage case files, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Penneo'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 Penneo to Claude or explore our broader architectural overview on connecting Penneo to AI Agents.

Giving a Large Language Model (LLM) read and write access to a secure electronic signature and compliance platform like Penneo is a serious engineering challenge. You have to handle OAuth 2.0 token lifecycles, translate complex multipart/form-data uploads into AI-friendly operations, and map dynamic form schemas into deterministic MCP tools. Every time Penneo updates an endpoint or modifies their form versioning rules, 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 Penneo, connect it natively to ChatGPT, and execute complex compliance workflows using natural language.

The Engineering Reality of the Penneo 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 Penneo's APIs - or maintaining custom connectors for 100+ other platforms - is painful. You aren't just integrating a standard CRUD database. Penneo handles legally binding documents and strict compliance data, which dictates a highly specific API architecture.

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

Asynchronous Case File Processing Creating a case file with PDF documents is not a synchronous operation. When you call the case file creation endpoint, you must pass a multipart/form-data payload containing both the document bytes and the signer configuration. The Penneo API accepts the request and returns a job reference ID, not the completed case file. Your MCP server must expose a secondary polling tool, and you must explicitly instruct the LLM to continuously poll the job status endpoint until the document processing completes. If your MCP server doesn't enforce this polling logic, ChatGPT will assume the document is ready for signing immediately and hallucinate success to the user.

Dynamic Form Submission Schemas Penneo Collect forms are completely customizable by end users. This means the API endpoint that returns form submission answers (list_all_penneo_casefile_answers) does not have a static JSON schema. The keys in the response payload map directly to the custom fields defined in that specific form version. If you are hand-coding an MCP server, you cannot provide the LLM with a hardcoded TypeScript interface for the response. You have to build a dynamic schema extraction layer that pulls the form definition first, translates it into JSON Schema, and feeds that context to the LLM so it knows how to parse the incoming answer data.

Strict Immutable Versioning Penneo enforces strict immutability on active forms to maintain audit trails. If an LLM attempts to update a form that is currently in an ACTIVE state, the API does not mutate the record in place. Instead, it creates an entirely new DRAFT version of the form. To make those changes live, the LLM must execute a distinct second tool call to publish that specific version. If your custom server abstracts this away poorly, the LLM will tell the user the form is updated, but end-users will still see the old version.

Raw IETF Rate Limiting Headers Penneo enforces strict rate limits to protect their infrastructure. When connecting AI agents, which can execute tight loops of tool calls, you will encounter 429 Too Many Requests errors. Truto's proxy architecture does not silently retry or absorb these errors. Instead, Truto passes the 429 response directly back to the caller, standardizing the upstream rate limit information into IETF spec headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller - in this case, the LLM framework - is entirely responsible for reading these headers and executing exponential backoff.

How to Create the Penneo MCP Server

Instead of building a translation layer from scratch, Truto dynamically generates an MCP server from your authenticated Penneo instance. Truto handles the OAuth token lifecycle and maps Penneo's resources into LLM-ready tool schemas automatically.

You can generate this secure endpoint in two ways: via the Truto Dashboard or programmatically via the API.

Method 1: Creating the Server via the Truto UI

If you are an IT admin or operations manager configuring an AI assistant for your team, the dashboard is the fastest path.

1. Log into your Truto account and navigate to the integrated account page for your connected Penneo instance.
2. Click the MCP Servers tab in the top navigation menu.
3. Click Create MCP Server.
4. Configure your server settings. You can restrict the server to specific methods (e.g., read-only access) or apply tags to limit which Penneo endpoints are exposed.
5. Click Save and copy the generated MCP Server URL (e.g., https://api.truto.one/mcp/abc123def456). This URL contains a cryptographic hash that authenticates the specific integration instance.

Method 2: Creating the Server via the API

If you are building an AI platform and need to provision MCP servers for your users dynamically, you can use the Truto API. This creates a dedicated, tenant-scoped MCP server backed by edge key-value storage for sub-millisecond authentication routing.

curl -X POST "https://api.truto.one/integrated-account/{integrated_account_id}/mcp" \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Penneo Forms Sync Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["forms", "casefiles"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API validates the configuration, ensures the Penneo connection has documented tools available, and returns a secure connection URL ready for immediate use.

How to Connect the MCP Server to ChatGPT

Once you have your Truto MCP URL, you can connect it to ChatGPT. You can do this visually through the ChatGPT interface or via a local configuration file for programmatic agent setups.

Method 1: Connecting via the ChatGPT UI

For enterprise users on ChatGPT Pro, Team, or Enterprise plans, you can add custom connectors directly in the web interface.

1. Open ChatGPT and navigate to Settings → Apps → Advanced settings.
2. Enable Developer mode (custom MCP support requires this flag to be active).
3. Under the MCP servers / Custom connectors section, click to add a new server.
4. Enter a Name (e.g., "Penneo Compliance Agent").
5. Paste your Truto MCP URL into the Server URL field.
6. Click Save. ChatGPT will immediately perform a handshake, validating the JSON-RPC 2.0 protocol and listing the available Penneo tools in the interface.

Method 2: Connecting via Manual Config File

If you are running a local instance of Claude Desktop, an IDE like Cursor, or a custom LangChain application that consumes standard MCP config files, you can use the Server-Sent Events (SSE) transport adapter.

Create or update your mcp-config.json file:

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

When your AI framework boots up, it will execute the npx command, connect to the Truto edge router, and ingest the Penneo schemas.

Penneo Hero Tools for AI Agents

Truto automatically generates precise, documented tools for Penneo's endpoints. Here are the highest-leverage tools available for document and form automation.

list_all_penneo_forms

Retrieves a paginated list of Penneo forms, allowing filtering by status (e.g., ACTIVE, DRAFT, ARCHIVED). The LLM uses this to discover available form templates before initiating a request.

"Find all the active KYC onboarding forms in our Penneo account so I can verify their current configurations."

create_a_penneo_casefile

Initiates the creation of a new Penneo case file with attached documents and signers via a multipart/form-data payload. Because this processing is asynchronous, the LLM will receive a job reference to poll.

"Create a new case file in Penneo for the vendor agreement. Upload the provided PDF and set John Doe as the primary electronic signer."

create_a_penneo_job_status

Checks the status of an asynchronous Penneo case file creation job. The LLM must poll this endpoint using the UUID and payload hash returned by the casefile creation tool until the status indicates success.

"Check the status of the case file job we just created. Let me know as soon as the document is processed and ready to be dispatched for signing."

list_all_penneo_casefile_answers

Retrieves all submission answers for a specific Penneo case file. Because the response shape depends entirely on the form's schema in Penneo Collect, the LLM must read the dynamic output to extract the relevant field values.

"Extract all the submitted answers from the onboarding case file for Acme Corp. Format the business registration number and the beneficial owner details into a summary table."

update_a_penneo_form_version_by_id

Updates a specific version of a Penneo form with new sections and input fields. If the form version is currently ACTIVE, this tool automatically generates a new DRAFT version with the modifications.

"Update the Non-Disclosure Agreement form template. Add a new required text field at the end of section 2 for 'Company Jurisdiction'."

create_a_penneo_form_publish

Publishes a specific DRAFT version of a Penneo form by its external ID, making it the active version available for end-users to complete.

"Take the draft version of the NDA form we just updated and publish it so it becomes the live version for all new vendor requests."

For the complete inventory of available tools, query schemas, and return types, review the Penneo integration page.

Workflows in Action

Giving ChatGPT access to these tools allows it to execute multi-step operations autonomously. Here are real-world examples of how AI agents interact with the Penneo MCP server.

Scenario 1: Automated KYC Data Extraction

Persona: Compliance Officer

"We just received the signed KYC forms for the new client, case file ID 98765. Pull their submitted answers, extract their primary business address and tax ID, and draft an approval note for our internal CRM."

Execution Steps:

1. list_all_penneo_casefile_answers: ChatGPT queries the case file ID. The Truto proxy executes the request and returns the dynamic form submission JSON.
2. Data Parsing: The LLM analyzes the unstructured JSON response, mapping the custom field keys (e.g., field_394_tax_id) to the semantic entities requested by the user.
3. Formatting: ChatGPT formulates the final summary note containing the extracted data, ready for the user to copy into their CRM.

Scenario 2: Async Case File Generation and Polling

Persona: HR Administrator

"Create a new employment contract case file for Jane Smith using this PDF document. Once the file is successfully processed by Penneo, confirm that it's ready."

Execution Steps:

1. create_a_penneo_casefile: ChatGPT submits the multipart payload containing the PDF data and signer configuration. Penneo returns an asynchronous job ID.
2. create_a_penneo_job_status: ChatGPT immediately polls the job status endpoint using the returned UUID.
3. Loop Execution: If the job is still pending, ChatGPT waits (applying backoff) and calls create_a_penneo_job_status again.
4. Completion: Once the job returns a success state, ChatGPT notifies the HR admin that the contract is staged and ready for signature routing.

sequenceDiagram
    participant User as User
    participant ChatGPT as "ChatGPT (LLM)"
    participant TrutoMCP as "Truto MCP Server"
    participant PenneoAPI as "Penneo API"

    User->>ChatGPT: "Create case file & notify when ready"
    ChatGPT->>TrutoMCP: Call tool: create_a_penneo_casefile
    TrutoMCP->>PenneoAPI: POST /api/v3/casefiles (multipart)
    PenneoAPI-->>TrutoMCP: 202 Accepted (Job UUID)
    TrutoMCP-->>ChatGPT: Return Job UUID
    ChatGPT->>TrutoMCP: Call tool: create_a_penneo_job_status
    TrutoMCP->>PenneoAPI: GET /api/v3/jobs/{uuid}
    PenneoAPI-->>TrutoMCP: Status: PROCESSING
    TrutoMCP-->>ChatGPT: Status: PROCESSING
    Note over ChatGPT: Agent decides to wait and retry
    ChatGPT->>TrutoMCP: Call tool: create_a_penneo_job_status
    TrutoMCP->>PenneoAPI: GET /api/v3/jobs/{uuid}
    PenneoAPI-->>TrutoMCP: Status: COMPLETED
    TrutoMCP-->>ChatGPT: Status: COMPLETED
    ChatGPT-->>User: "Case file is successfully processed and ready!"

Security and Access Control

Exposing legally binding signature pipelines and KYC data to an LLM requires strict governance. Truto's MCP architecture provides native security controls at the token layer:

• Method Filtering: You can configure the MCP token config.methods to only allow "read" operations. This ensures ChatGPT can summarize form answers but cannot accidentally create new case files or alter form schemas.
• Tag Filtering: By applying tags in config.tags (e.g., ["compliance"]), you can restrict the MCP server to only expose endpoints relevant to that specific domain, hiding administrative or billing endpoints from the LLM.
• Expiration Controls: You can set an expires_at datetime on the MCP server. Once expired, the underlying edge database automatically invalidates the token, revoking ChatGPT's access entirely. Ideal for temporary contractor access.
• Strict Authentication: Setting require_api_token_auth: true on the MCP server forces the client (ChatGPT or custom agents) to pass a valid Truto API token alongside the URL hash, providing a robust second layer of authentication.

Connect Penneo to ChatGPT Today

Building a reliable, polling-aware, dynamic-schema integration for Penneo is not a weekend project. Between managing OAuth refreshes, handling multipart data streams, and mapping dynamic API responses into deterministic MCP tools, custom server builds drain engineering resources.

Truto handles the entire API abstraction layer. You authenticate the Penneo account, generate the MCP server URL, and your AI agents get immediate, secure access to your document workflows.