--- title: "Connect PandaDoc to ChatGPT: Manage Document Creation and Signing" slug: connect-pandadoc-to-chatgpt-manage-document-creation-and-signing date: 2026-07-08 author: Yuvraj Muley categories: ["AI & Agents"] excerpt: "Learn how to connect PandaDoc to ChatGPT using a managed MCP server. Execute document generation, signature tracking, and templating workflows directly via AI." tldr: "Connect PandaDoc to ChatGPT via Truto's managed MCP server to automate document creation, tracking, and signatures. We cover PandaDoc API realities, server setup via UI/API, and real-world agent workflows." canonical: https://truto.one/blog/connect-pandadoc-to-chatgpt-manage-document-creation-and-signing/ --- # Connect PandaDoc to ChatGPT: Manage Document Creation and Signing You want to connect PandaDoc to ChatGPT so your AI agents can draft proposals, track e-signatures, and query document statuses using natural language. If your team uses Claude, check out our guide on [connecting PandaDoc to Claude](https://truto.one/connect-pandadoc-to-claude-scale-templates-and-workspace-operations/), or explore our broader architectural overview on [connecting PandaDoc to AI Agents](https://truto.one/connect-pandadoc-to-ai-agents-automate-catalog-and-notary-workflows/). Giving a Large Language Model (LLM) read and write access to a document generation platform is a significant engineering challenge. You either spend weeks [building, hosting, and maintaining a custom MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), or you use a managed infrastructure layer that [dynamically generates tools](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) and handles protocol translation. This guide breaks down exactly how to use Truto to generate a secure, managed [Model Context Protocol (MCP)](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) server for PandaDoc, [connect it natively to ChatGPT](https://truto.one/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/), and execute complex contract workflows without writing integration boilerplate. ## The Engineering Reality of the PandaDoc API A custom MCP server is a self-hosted integration layer that translates an LLM's tool calls into REST API requests. While the MCP standard provides a predictable way for models to discover tools, implementing it against vendor APIs requires intimate knowledge of their specific design patterns. If you build a custom MCP server for PandaDoc, you own the entire integration lifecycle. Here are the specific engineering realities you must accommodate: ### The Asynchronous Document State Machine Creating a document in PandaDoc is not a synchronous operation. When you send a request to create a document from a template, PandaDoc returns an initial response placing the document in a `document.uploaded` or `document.draft` state. It is not immediately ready to be sent or modified. Your agent must implement a polling loop against the `status` endpoint to verify the document has reached a usable state before executing subsequent tool calls. If your MCP server doesn't provide explicit schemas and instructions for this, the LLM will hallucinate a success state and attempt to fire off a contract that isn't ready. ### Nested Schemas vs. Flat LLM Arguments PandaDoc relies heavily on variable replacement (`tokens`) and dynamic field assignment (`fields`). When creating a document, the JSON body requires deeply nested arrays of objects mapping specific UUIDs to values. However, MCP clients (like ChatGPT) prefer to send a single, flat JSON object containing all arguments. Truto handles this translation automatically—it parses the flat arguments provided by the LLM and splits them into the distinct query string parameters and nested JSON body objects dictated by PandaDoc's actual API schema. ### Strict Rate Limits and 429 Errors PandaDoc enforces strict API rate limits (typically 100 requests per minute). When an LLM is iterating through a list of 50 stalled contracts to summarize them, it is incredibly easy to hit this ceiling. **Note on how Truto handles this:** Truto does not retry, throttle, or apply exponential backoff on rate limit errors. When the PandaDoc API returns an HTTP `429 Too Many Requests`, Truto passes that exact error directly to the caller (ChatGPT). What Truto *does* do is normalize the upstream rate limit data into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller (or your custom agent framework bridging to ChatGPT) is fully responsible for implementing retry and backoff logic. ## Step 1: Creating the PandaDoc MCP Server Rather than hand-coding tool definitions, Truto derives them dynamically from the integration's resource definitions and schema documentation. A tool only appears in the MCP server if it has a corresponding documentation entry, ensuring the LLM only interacts with curated, well-described endpoints. Each MCP server is scoped to a single integrated PandaDoc account and authenticated via a secure, cryptographically hashed token embedded in the URL. You can create this server in two ways. ### Method A: Via the Truto UI 1. Navigate to the **Integrated Accounts** page for your PandaDoc connection. 2. Click on the **MCP Servers** tab. 3. Click **Create MCP Server**. 4. Select your desired configuration. You can filter by methods (e.g., read-only), specific tags, or set a hard expiration date. 5. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`). ### Method B: Via the API For teams deploying agents programmatically, you can provision the server via a standard REST call to Truto. ```bash curl -X POST "https://api.truto.one/integrated-account//mcp" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{ "name": "ChatGPT PandaDoc Integration", "config": { "methods": ["read", "write", "custom"], "require_api_token_auth": false } }' ``` The response contains your database record and the secure URL needed by the client: ```json { "id": "abc-123", "name": "ChatGPT PandaDoc Integration", "config": { "methods": ["read", "write", "custom"] }, "expires_at": null, "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..." } ``` ## Step 2: Connecting the Server to ChatGPT Once you have the URL, you need to register it with your ChatGPT environment. The MCP protocol uses JSON-RPC 2.0 over HTTP POST, meaning the URL is completely self-contained. ### Option A: Using the ChatGPT UI (Custom Connectors) If you have a ChatGPT Plus, Pro, Team, or Enterprise account with Developer mode enabled: 1. In ChatGPT, navigate to **Settings → Apps → Advanced settings**. 2. Toggle **Developer mode** to ON. 3. Under the Custom Connectors / MCP Servers section, click **Add new server**. 4. **Name:** Enter a descriptive name (e.g., "PandaDoc Contracts"). 5. **Server URL:** Paste the Truto MCP URL generated in the previous step. 6. Click **Save**. ChatGPT will immediately execute an `initialize` handshake and request the `tools/list` to discover your PandaDoc capabilities. ### Option B: Local Config for Custom ChatGPT Interfaces If you are running a custom desktop agent, a LangGraph pipeline, or leveraging an open-source ChatGPT UI clone, you can connect the server via a standard `mcp.json` configuration file, utilizing the Server-Sent Events (SSE) bridge if required by your specific client framework: ```json { "mcpServers": { "pandadoc": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-sse", "--url", "https://api.truto.one/mcp/a1b2c3d4e5f6..." ] } } } ``` ## PandaDoc Hero Tools for ChatGPT Truto dynamically generates highly descriptive snake_case tool names and JSON schemas directly from the PandaDoc API reference. Here are 6 high-leverage hero tools your AI agent can now access. *(Note: For the complete inventory of available tools, view the [PandaDoc integration page](https://truto.one/integrations/detail/pandadoc).)* ### 1. List Templates (`list_all_panda_doc_public_templates`) This tool retrieves all available templates in your PandaDoc workspace. ChatGPT can use this to locate the exact template ID needed before attempting to draft a new contract. > "I need to generate a new service agreement. Can you search my PandaDoc templates for anything related to 'Master Services', tell me the template ID, and list the variables it expects?" ### 2. Create Document (`create_a_panda_doc_public_document`) This is the core execution tool. It allows the LLM to post a payload containing a template ID, tokens (variables), and recipient information. It returns the newly created document UUID. > "Use template ID 'X' to draft a new Master Services Agreement for Acme Corp. Assign the {{company_name}} token to 'Acme Corp' and set the primary recipient to jane@acmecorp.com." ### 3. Document Details (`list_all_panda_doc_document_details`) Retrieves the full metadata for a specific document, including field values, tokens, pricing tables, and routing status. This is crucial for auditing contracts or preparing summaries. > "Pull the details for document ID 'Y'. I need a summary of the pricing table totals and a list of all recipients who haven't viewed the document yet." ### 4. Send Document (`panda_doc_public_documents_send`) Triggers the outbound email delivery of a drafted document. The LLM must ensure the document has moved past the `document.draft` state before calling this tool. > "The proposal for Globex is finalized. Please execute the send operation so it goes out to their primary contact for signature. Confirm the status once dispatched." ### 5. Document Status (`get_single_panda_doc_public_document_by_id`) A lightweight polling tool that returns the current status (e.g., `document.draft`, `document.sent`, `document.completed`) without the heavy payload of the full document details. > "Check the status of the Globex proposal every 30 minutes. Let me know the moment the status changes to completed." ### 6. Create Embedded Session (`create_a_panda_doc_document_session`) Generates a secure, temporary URL for embedded signing. This allows you to host the signing experience inside your own application portal rather than relying on PandaDoc's default email delivery. > "Generate an embedded signing session link for recipient bob@example.com on document ID 'Z'. Ensure the link expires in 45 minutes." ## Workflows in Action When you give ChatGPT access to these tools, it acts as an autonomous orchestration layer. Below are two real-world sequences demonstrating how the LLM translates prompts into multi-step API execution. ### Scenario 1: Automated Proposal Generation **The Prompt:** > "A new deal just closed for Wayne Enterprises. Find the 'Standard NDA' template, generate a new document for bruce@wayne.com, verify it's ready, and then send it to him immediately." **The Execution Sequence:** 1. **`list_all_panda_doc_public_templates`**: ChatGPT queries the templates and identifies the UUID for "Standard NDA". 2. **`create_a_panda_doc_public_document`**: The agent posts the payload, passing the template UUID and injecting `bruce@wayne.com` into the recipient array. It captures the newly generated Document ID from the response. 3. **`get_single_panda_doc_public_document_by_id`**: The agent checks the status of the new document. If it returns `document.uploaded`, the agent knows to wait and retry. Once it sees `document.draft`, it proceeds. 4. **`panda_doc_public_documents_send`**: The agent fires the send command, moving the contract to `document.sent`. **The Output:** ChatGPT replies: *"The Standard NDA has been generated and sent to bruce@wayne.com. The Document ID is [UUID] and the current status is successfully marked as 'sent'."* ### Scenario 2: E-Signature Audit & Embedded Link Generation **The Prompt:** > "Review all documents created in the last 7 days. Find any that are stuck in 'sent' status. For the ones waiting on John Doe, generate embedded signing links so I can ping him over Slack." **The Execution Sequence:** 1. **`list_all_panda_doc_public_documents`**: ChatGPT fetches the list of recent documents, filtering the results in memory for the `document.sent` status. 2. **`list_all_panda_doc_document_details`**: For each stalled document, it calls the details endpoint to inspect the `recipients` array, specifically looking for "John Doe" where `has_completed` is false. 3. **`create_a_panda_doc_document_session`**: For the matching documents, it passes the Document ID and John Doe's email to generate an active signing session token. **The Output:** ChatGPT replies: *"I found 2 documents waiting on John Doe. Here are the embedded signing links you can send him over Slack. Please note these links expire in 60 minutes..."* ```mermaid sequenceDiagram participant ChatGPT as "ChatGPT (Client)" participant TrutoMCP as "Truto MCP Router" participant PandaDoc as "PandaDoc API" ChatGPT->>TrutoMCP: POST /tools/call (List Documents) TrutoMCP->>PandaDoc: GET /public/v1/documents PandaDoc-->>TrutoMCP: 200 OK (Array of documents) TrutoMCP-->>ChatGPT: JSON-RPC Result (Flat array) ChatGPT->>TrutoMCP: POST /tools/call (Create Session) Note right of ChatGPT: LLM identifies stalled doc
and requests session link TrutoMCP->>PandaDoc: POST /public/v1/documents/{id}/session PandaDoc-->>TrutoMCP: 201 Created (Session URL) TrutoMCP-->>ChatGPT: JSON-RPC Result (URL string) ``` ## Security and Access Control Giving an LLM unconstrained write access to your enterprise contract platform is dangerous. Truto provides several mechanisms to lock down your generated MCP servers: * **Method Filtering:** By defining `config.methods: ["read"]` during server creation, you completely strip `create`, `update`, and `delete` tools from the LLM's context. It physically cannot sign or delete documents. * **Tag Filtering:** You can restrict tools using `config.tags`. If you only want the LLM to access templating tools, you can isolate the server to resources tagged specifically with `["templates"]`. * **Strict Authentication (`require_api_token_auth`):** By default, possessing the Truto MCP URL grants access. By setting this flag to `true`, the connecting client must also pass a valid Truto API token in the `Authorization` header, preventing unauthorized execution if the URL leaks. * **Ephemeral Servers (`expires_at`):** You can pass an ISO datetime to the server config. Truto relies on distributed KV store expirations and durable scheduled alarms to completely eradicate the token and its database record the second it expires. ## Stop Building Integration Boilerplate Building a custom ChatGPT connector for PandaDoc means taking ownership of complex OAuth lifecycles, nested JSON schema mapping, dynamic pagination handling, and ongoing API maintenance. Truto’s unified architecture and dynamic tool generation handle the entire protocol translation layer out of the box. Your team can connect PandaDoc to an AI agent in minutes, strictly control the security blast radius, and execute complex contract workflows using natural language. > Stop wasting engineering cycles on third-party API boilerplate. Book a technical deep dive with our team to see how Truto manages AI agent tool execution at enterprise scale. > > [Talk to us](https://cal.com/truto/partner-with-truto)