--- title: "Connect Planful to ChatGPT: Streamline Data Loads & Financial Reports" slug: connect-planful-to-chatgpt-streamline-data-loads-financial-reports date: 2026-10-22 author: Riya Sethi categories: ["AI & Agents"] excerpt: "Learn how to connect Planful to ChatGPT using a managed MCP server. Automate data loads, GL data extraction, and financial reporting with natural language." tldr: Connect Planful to ChatGPT in minutes using Truto's auto-generated MCP server. This guide details how to bypass Planful's complex dual-auth and chunking limits to automate financial operations. canonical: https://truto.one/blog/connect-planful-to-chatgpt-streamline-data-loads-financial-reports/ --- # Connect Planful to ChatGPT: Streamline Data Loads & Financial Reports If you need to connect Planful to ChatGPT to automate Data Load Rules (DLRs), extract General Ledger (GL) data, or orchestrate financial reporting workflows, you need a [Model Context Protocol (MCP) server](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/). This server translates ChatGPT's natural language tool calls into Planful's complex REST and Dynamic Planning APIs. You can either build and maintain this custom infrastructure yourself, or use a managed integration platform like Truto to [dynamically generate a secure, authenticated MCP server URL](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) in seconds. If your team uses Claude, check out our guide on [connecting Planful to Claude](https://truto.one/connect-planful-to-claude-sync-gl-data-manage-model-hierarchies/) or explore our broader architectural overview on [connecting Planful to AI Agents](https://truto.one/connect-planful-to-ai-agents-automate-models-user-access-control/). Giving a Large Language Model (LLM) read and write access to an enterprise FP&A platform like Planful is a heavy engineering lift. Planful is not a simple CRUD application. It utilizes dual authentication systems, relies heavily on asynchronous data batching with strict 40MB chunk limits, and demands complex OData filtering to extract nested financial hierarchies. Every time you want to expose a new model or calculation to your AI agent, a hardcoded custom MCP server requires code updates and redeployments. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Planful, connect it natively to ChatGPT, and execute complex financial workflows using natural language. > Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds. > > [Talk to us](https://truto.one/book-a-demo/) ## The Engineering Reality of the Planful 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 Planful's API surface exposes your engineering team to several domain-specific integration hurdles. If you decide to build a custom MCP server for Planful, you own the entire integration lifecycle. Here are the specific challenges that break standard API assumptions when working with Planful: ### Dual Authentication Systems Planful operates on two distinct architectural tracks. The core REST API (used for GL data, DLRs, and users) authenticates via an Access ID and Access Key. However, the Dynamic Planning API (used for Master/Analytic models, calculations, and leaf data clearing) requires a completely different `X-Access-Token` mechanism. If you build your own MCP server, your middleware must inspect the requested endpoint, determine the routing context, and dynamically inject the correct authentication headers. Truto's SuperAI platform abstracts this entirely, proxying the requests with the correct credentials automatically. ### Asynchronous Data Load Rules (DLRs) and Chunking You cannot simply HTTP POST a 500MB financial ledger into Planful. Data ingestion requires Data Load Rules. When building an MCP server for data transfers, your tool definitions must enforce a 40MB maximum payload size per request. If a file exceeds this, your agent must split the payload, send chunks via the bulk update endpoint, and explicitly finalize the batch by sending an `IsLoadCompleted=true` header. Furthermore, the DLR triggers an asynchronous job, meaning the LLM must be equipped with polling tools to check the `ExecutionId` status until it returns `Processed`. ### Complex OData Filtering on Segment Data Financial reporting in Planful relies heavily on Segment hierarchies. The GL Data Extract API retrieves data only for leaf-level members in Segments 1 through 8. Attempting to pull everything at once will time out. Your MCP query schemas must force the LLM to provide explicit Scenario parameters and `$filter` OData strings to paginate through segments. Writing static JSON Schema definitions that accurately guide an LLM to formulate valid OData queries is notoriously difficult to maintain. ## Generating the Planful MCP Server To connect Planful to ChatGPT, you first need to generate a self-contained MCP server URL. Truto automatically builds this server dynamically based on the Planful API documentation and schemas. Truto scopes every MCP server to a single integrated account (a specific tenant's connected Planful instance). The resulting URL contains a cryptographically hashed token that securely authenticates the request and scopes the available tools. You can create this server in two ways. ### Method 1: Via the Truto UI For quick prototyping or internal tooling, generating the server via the dashboard is the fastest route. 1. Log into your Truto dashboard and navigate to **Integrated Accounts**. 2. Select your connected Planful account. 3. Click the **MCP Servers** tab. 4. Click **Create MCP Server**. 5. Configure your server. You can restrict the server to specific operations (e.g., `read` only) or specific tags (e.g., `data_loads`, `gl_data`). 6. Click Save and **copy the generated MCP server URL** (it will look like `https://api.truto.one/mcp/a1b2c3d4...`). ### Method 2: Via the API For production use cases where you are provisioning AI agents programmatically, you should generate MCP servers via the Truto REST API. Make a POST request to `/integrated-account/:id/mcp`. You can pass configuration objects to explicitly filter which Planful endpoints the LLM can access. ```bash curl -X POST https://api.truto.one/integrated-account//mcp \ -H "Authorization: Bearer $TRUTO_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "Planful Financial Reporting Agent", "config": { "methods": ["read", "write", "custom"], "tags": ["gl_data", "data_load_rules", "models"] } }' ``` The API responds with the secure URL that ChatGPT will use to discover and execute tools: ```json { "id": "mcp_8a9b0c", "name": "Planful Financial Reporting Agent", "expires_at": null, "url": "https://api.truto.one/mcp/abc123def456..." } ``` Treat this URL as a sensitive credential. It encapsulates the routing logic, the unified schemas, and the authentication state for that specific Planful environment. ## Connecting the MCP Server to ChatGPT Once you have your Truto MCP URL, you need to register it with ChatGPT. ChatGPT operates as the MCP Client, sending `tools/list` and `tools/call` JSON-RPC 2.0 messages to the Truto MCP server. ### Method 1: Via the ChatGPT UI (Custom Connectors) If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education, you can add the server directly via the interface. 1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**. 2. Toggle **Developer mode** to ON. 3. Under **MCP servers / Custom connectors**, click **Add new server**. 4. Enter a descriptive name (e.g., "Planful Finance System"). 5. Paste the Truto MCP server URL into the **Server URL** field. 6. Click **Save**. ChatGPT will immediately ping the server, complete the initialization handshake, and populate its context window with the available Planful tools. ### Method 2: Via Manual Config File (SSE Transport) If you are running a custom headless agent, deploying a desktop application, or using a framework that requires standard MCP configuration files, you can use the official `@modelcontextprotocol/server-sse` package to proxy the connection. Create or update your MCP configuration JSON file: ```json { "mcpServers": { "planful_production": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-sse", "--url", "https://api.truto.one/mcp/abc123def456..." ] } } } ``` When your agent boots, it spawns this process, connecting via Server-Sent Events (SSE) to Truto's hosted infrastructure. ## Planful Hero Tools for ChatGPT Truto automatically translates Planful's API documentation into JSON Schema formats optimized for LLM consumption. Here are a few high-leverage tools available on the Planful MCP server. ### Create a Planful Data Transfer File `create_a_planful_data_transferfile` This tool allows the agent to upload CSV or ZIP data files into Planful through a defined Data Load Rule. The server expects base64-encoded file payloads. > "Upload this base64 encoded CSV string containing the Q2 adjustments into the Planful data load rule named 'Q2_Adj_Load' using a comma delimiter." ### List All Planful Data Load Status `list_all_planful_data_load_status` Because data transfers are asynchronous, the agent must check the execution status using the `ExecutionId` returned by the upload tool. > "Check the status of the Planful data load using Execution ID 'EX-99812'. If it is still 'Processing', wait and check again. Let me know when it says 'Processed'." ### Complete a Batched Data Transfer `planful_data_transfers_complete` For large datasets exceeding 40MB, the agent must finalize the batch load. This tool explicitly sends the `IsLoadCompleted=true` flag so Planful knows the transfer is finished. > "We have finished sending the three 35MB chunks for the 'FY_Revenue_Dump' rule. Send the completion signal to Planful to close the load." ### List All Planful GL Data `list_all_planful_gl_data` Retrieves General Ledger data. The LLM is instructed via the schema that providing the `Scenario` parameter is mandatory, and if requesting Actuals, the `FiscalYear` is required. > "Pull the GL data from Planful for the 'Actual' scenario for the 2023 fiscal year. Filter for segment 1 entries starting with 'REV'." ### Planful Report Data Search `planful_report_data_search` Extracts metadata and tabular data directly from financial reports built inside Planful. The tool returns structured row headers, column headers, and data arrays. > "Fetch the financial report data for report code 'BOARD-Q3-SUMMARY' using the default lineage and cube name." ### Create a Planful Budget Entity Hierarchy Export `create_a_planful_budget_entity_hierarchy_export` Exports the organizational Budget Entity hierarchy. The LLM can specify whether it needs the structure as a Tree, Parent-Child list, or Level-Based format. > "Export the Budget Entity hierarchy from Planful in a Parent-Child format so I can map the new cost centers to their parent nodes." *This is only a subset of the available operations. For the complete tool inventory, including model calculations, attribute appending, and user provisioning tools, visit the [Planful integration page](https://truto.one/integrations/detail/planful).* ## Workflows in Action Exposing individual endpoints to ChatGPT is useful, but the real power of MCP lies in multi-step orchestration. When the LLM understands the schemas, it can string operations together autonomously. ### Scenario 1: End-of-Month Financial Report Consolidation At month-end, a finance director needs to pull a specific board report and cross-reference it against raw GL data to investigate a variance. > "Pull the 'MONTH-END-NOV' report from Planful. Check the revenue line items. Then, pull the raw GL data for the 'Actual' scenario, Fiscal Year 2024, to list all individual transactions that roll up into Segment 1 code 'REV-400'." **How the agent executes this:** 1. The agent calls `planful_report_data_search` passing `ReportCode: "MONTH-END-NOV"`. 2. It parses the returned `RowHeaders` and `Data` arrays to identify the revenue totals. 3. Recognizing it needs underlying GL data, it calls `list_all_planful_gl_data` with `Scenario: "Actual"`, `FiscalYear: "2024"`, and a query filter for `Segment1: "REV-400"`. 4. The agent cross-references the raw GL data against the report summary and formats a variance explanation for the user. ```mermaid sequenceDiagram participant User as User participant Agent as ChatGPT (MCP Client) participant Truto as Truto MCP Server participant Upstream as Upstream API (Planful) User->>Agent: "Pull MONTH-END-NOV report..." Agent->>Truto: tools/call (planful_report_data_search) Truto->>Upstream: POST /GetReportData Upstream-->>Truto: Report JSON (RowHeaders, ColumnHeaders) Truto-->>Agent: Report Data Payload Agent->>Truto: tools/call (list_all_planful_gl_data) Truto->>Upstream: GET /GLData Extract (Scenario=Actual) Upstream-->>Truto: GL Transaction Rows Truto-->>Agent: Segment 1 Payload Agent-->>User: Variance analysis summary ``` ### Scenario 2: Orchestrating an Asynchronous Data Transfer An IT admin needs to load an updated CSV of organizational attributes into Planful and verify it completes successfully. > "Take this base64 CSV string containing our new cost centers and push it to the Planful Data Load Rule 'Org_Hierarchy_Update'. Wait until the load is completely processed and tell me how many records were received." **How the agent executes this:** 1. The agent calls `create_a_planful_data_transferfile` with `data_load_rule_name: "Org_Hierarchy_Update"` and the file string. 2. Truto routes this to Planful and returns a payload containing an `ExecutionId` (e.g., `EXE-10928`). 3. The agent reads the `ExecutionId` from the response. 4. The agent autonomously loops, calling `list_all_planful_data_load_status` with `ExecutionId: "EXE-10928"`. 5. If the `ExecutionStatus` is `Processing`, the agent pauses and polls again. 6. Once the status hits `Processed`, it reads `RecordsReceived` and reports back to the user. ## Security and Access Control When granting AI agents access to sensitive financial environments, strict boundaries are required. Truto provides several mechanisms to [lock down your Planful MCP servers](https://truto.one/zero-data-retention-mcp-servers-building-soc-2-gdpr-compliant-ai-agents/): * **Method Filtering:** Limit the server strictly to safe operations. By passing `methods: ["read"]` during server creation, Truto will physically drop all `create`, `update`, and `delete` tools from the LLM's context window. It becomes impossible for the agent to accidentally overwrite financial models. * **Tag Filtering:** Restrict access by resource domain. By passing `tags: ["gl_data", "reports"]`, you ensure the agent can run reports but cannot touch User Administration or Application Settings. * **Extra Authentication (`require_api_token_auth`):** By default, possessing the MCP URL grants access. By enabling this flag, the calling agent must also pass a valid Truto API token via a Bearer header, adding a secondary identity check. * **Automatic Expiration (`expires_at`):** You can set an ISO timestamp when creating the server. Truto will schedule a durable alarm to permanently delete the server and its KV credentials at that exact moment - perfect for temporary auditing access. * **Factual note on rate limits:** Truto does not retry, throttle, or apply backoff on rate limit errors. When Planful returns an HTTP 429, Truto passes that error directly to the caller and normalizes the upstream rate limit info into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. Your MCP client (ChatGPT) is responsible for reading these headers and executing retry/backoff logic. ## Moving Past Manual Integration Maintenance Building an MCP server for Planful in-house means assigning engineers to monitor API version changes, maintain XML/JSON parsers for GL data, manage DLR chunking state machines, and handle dual authentication protocols. By leveraging Truto, you replace that entire infrastructure burden with a single API call. Your Planful MCP server is derived dynamically from live API documentation, ensuring tool definitions remain accurate without code deployments. Focus on building incredible, agentic financial workflows. Let Truto handle the integration layer. > Ready to give your AI agents secure access to Planful? Generate your first managed MCP server with Truto today. > > [Talk to us](https://truto.one/book-a-demo/)