Connect Arcadia to ChatGPT: Analyze Utility Bills and Usage

If you need to connect Arcadia to ChatGPT to automate utility bill analysis, extract interval meter data, or audit enterprise energy usage, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Arcadia'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 Arcadia to Claude or explore our broader architectural overview on connecting Arcadia to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling ecosystem of utility data is an engineering challenge. Arcadia abstracts thousands of fragmented utility providers into a single platform, but navigating its APIs programmatically still requires handling asynchronous polling, massive time-series datasets, and complex authentication flows. Every time Arcadia 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 Arcadia, connect it natively to ChatGPT, and execute complex utility data workflows using natural language.

The Engineering Reality of the Arcadia 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 Arcadia's APIs - or maintaining custom connectors for any other enterprise platform - is painful. You aren't just integrating a standard CRUD application; you are integrating a gateway to thousands of legacy utility providers.

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

Two-Step Asynchronous File Downloads When an LLM wants to analyze utility statements or bulk meter intervals, it cannot simply execute a GET request and receive a CSV. Arcadia uses a mandatory two-step asynchronous architecture for heavy payloads. First, you must POST to a prepare-download endpoint (like create_a_arcadia_statements_download). This returns a payload containing a URL. To get the actual file, the caller must extract an identifier from that URL, append a token without spaces, and repeatedly poll a secondary stream endpoint until it returns an HTTP 200 instead of an HTTP 202. Instructing an LLM to reliably manage this polling state machine without hallucinating success is incredibly difficult if your MCP server does not expose these endpoints cleanly.

Handling 15-Minute Interval Data Windows Extracting granular energy consumption requires pulling 15-minute interval data. Arcadia limits these API requests to a maximum of a 1-year window per call. If a ChatGPT user prompts, "Analyze my energy usage since 2021," the LLM must mathematically chunk the date ranges, execute multiple sequential API calls to get_single_arcadia_normalized_intervals_meter_by_id, and stitch the resulting arrays together in memory. If your MCP tools do not enforce strict schema validation for these startAt and endAt parameters, the Arcadia API will reject the request.

Rate Limits and 429 Exhaustion Arcadia enforces strict rate limits to protect both its infrastructure and the fragile legacy utility portals it connects to. If your AI agent gets stuck in a loop attempting to poll a download link or pull intervals for 500 meters at once, Arcadia will return a 429 Too Many Requests error. Truto does not retry, throttle, or absorb these rate limit errors. Instead, Truto translates the upstream constraints into standardized ratelimit-limit, ratelimit-remaining, and ratelimit-reset HTTP headers per the IETF specification and passes the 429 directly to the caller. Your client or LLM orchestration layer is strictly responsible for inspecting these headers and implementing its own exponential backoff, which is a critical part of handling third-party API rate limits in AI agent architectures.

The Managed MCP Approach

Instead of forcing your engineering team to build a custom Express or FastAPI server, manage deployment infrastructure, and map Arcadia's nested JSON schemas into MCP format manually, Truto provides a managed alternative. Truto automatically generates a secure, production-ready MCP server for any connected Arcadia account.

The tool generation is dynamic and documentation-driven. Truto maps Arcadia's REST endpoints into a flat tool namespace, extracting the query and body parameter schemas automatically. This means pagination parameters, required fields, and endpoint descriptions are injected directly into the LLM's context window.

How to Create the Arcadia MCP Server

Truto creates MCP servers scoped to a specific integrated account. This ensures strong tenant isolation - an MCP server generated for Client A's Arcadia workspace cannot access Client B's data.

Method 1: Via the Truto UI

The fastest way to generate an MCP server is directly through the Truto dashboard.

1. Log into your Truto account and navigate to the integrated account page for your Arcadia connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (you can restrict tools to read-only operations, filter by specific tags, or set an expiration date).
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For teams building automated onboarding flows, you can programmatically provision MCP servers when a customer connects their Arcadia account, a process following the patterns in our MCP architecture guide for SaaS users. Execute a POST request to the Truto API:

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": "Energy Analyst AI Server",
    "config": {
      "methods": ["read", "write"]
    }
  }'

The response will contain the secure URL you need to route to ChatGPT:

{
  "id": "mcp_srv_987654321",
  "name": "Energy Analyst AI Server",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

How to Connect the MCP Server to ChatGPT

Once you have your Truto MCP URL, you can connect it directly to ChatGPT or any standard MCP client.

Method 1: Via the ChatGPT UI

If you are using ChatGPT Enterprise, Edu, or Plus with developer features enabled, you can add the server directly through the interface.

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to ON.
3. Under the custom connectors or MCP servers section, click Add new server.
4. Provide a descriptive name (e.g., "Arcadia Utility Sync").
5. Paste the Truto MCP server URL and click Add.

ChatGPT will perform a brief handshake, verifying the JSON-RPC 2.0 endpoints, and immediately index the available Arcadia tools.

Method 2: Via Manual Configuration (Local Client)

If you are running a custom LangChain script or a local desktop client that requires an SSE transport adapter, you can configure it using the official MCP CLI proxy.

Create a config.json file:

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

When your local agent boots, it routes local MCP JSON-RPC messages through the SSE proxy directly to Truto's edge network, executing the API requests against Arcadia.

Arcadia Hero Tools for ChatGPT

Once connected, your AI agent has access to Arcadia's API via strongly typed tools. Here are the highest-leverage operations for energy analysis workflows.

Discover Connected Utility Credentials

The list_all_arcadia_plug_credentials tool lists all utility credentials submitted to the Arcadia platform, revealing the underlying utility providers and account associations.

"Fetch all active utility credentials in Arcadia. Group them by provider name and tell me if any require customer action to fix authentication issues."

Retrieve High-Level Statement Summaries

The list_all_arcadia_plug_statements tool fetches metadata about recent utility bills, including total charges, billing periods, and outstanding balances, without downloading the raw PDF.

"List all statements for account ID 109988 for the last 6 months. Calculate the total amount due across this period and identify the month with the highest total charges."

Fetch Granular 15-Minute Interval Data

The get_single_arcadia_normalized_intervals_meter_by_id tool is the powerhouse for deep energy analysis, returning normalized 15-minute interval energy readings for a specific meter.

"Retrieve the normalized 15-minute interval data for meter ID 554433 between June 1st and August 31st. Summarize the peak energy consumption times for each week in that window."

List Active Meters Across Sites

The list_all_arcadia_plug_meters tool returns the physical meter infrastructure, mapping meters to logical sites and utility accounts.

"List all active meters associated with site ID 887766. Provide a breakdown of their service types, such as electric versus gas."

Upload Utility PDFs for OCR

The create_a_arcadia_plug_file tool allows the agent to submit raw utility statement PDFs directly into Arcadia's OCR ingestion pipeline for processing.

"I am going to provide a raw base64 string of a newly received utility PDF. Use the Arcadia upload tool to submit this file for statement discovery and OCR processing."

Initiate Statement CSV Downloads

The create_a_arcadia_statements_download tool acts as the first step in Arcadia's two-step download architecture, preparing a structured CSV report of statements.

"Initiate a CSV statement download request for statement IDs 101, 102, and 103. Return the exact webhook polling URL generated by Arcadia."

To view the complete schema definitions and the full inventory of available endpoints, visit the Arcadia integration page.

Workflows in Action

Individual tools are useful, but the real power of an MCP server emerges when an LLM orchestrates complex workflows autonomously. Here is how ChatGPT handles real-world utility management scenarios using the Truto MCP server.

Workflow 1: The Multi-Site Energy Cost Audit

Enterprise facility managers constantly audit energy spend across hundreds of distributed locations. Compiling this manually requires downloading individual bills from dozens of disconnected utility portals.

"Run a complete energy cost audit for all active sites in the organization for the previous quarter. Identify the top 3 most expensive sites and list the exact utility providers serving them."

1. Discover Sites and Accounts: ChatGPT calls list_all_arcadia_plug_sites to get the master roster of facility locations.
2. Map Accounts to Credentials: For the identified sites, it calls list_all_arcadia_plug_credentials to determine which utility providers are actively connected to those locations.
3. Extract Billing Data: The agent loops over the relevant account IDs, calling list_all_arcadia_plug_statements filtered by the previous quarter's date range.
4. Synthesize and Rank: The LLM analyzes the totalCharges fields from the JSON payloads, ranks the sites by total spend, and outputs the final requested audit report.

sequenceDiagram
    participant User
    participant ChatGPT as ChatGPT (Client)
    participant Truto as Truto MCP Server
    participant Arcadia as Arcadia API
    
    User->>ChatGPT: "Run energy cost audit for all sites..."
    ChatGPT->>Truto: Call tool: list_all_arcadia_plug_sites
    Truto->>Arcadia: GET /sites
    Arcadia-->>Truto: Site array
    Truto-->>ChatGPT: Site IDs
    
    ChatGPT->>Truto: Call tool: list_all_arcadia_plug_statements
    Truto->>Arcadia: GET /statements?dateRange=...
    Arcadia-->>Truto: Statement summaries
    Truto-->>ChatGPT: Financial data
    
    ChatGPT->>User: Renders top 3 expensive sites

Workflow 2: Granular Demand Peak Analysis

Sustainability engineers need to understand exactly when facilities hit peak demand to negotiate better rates or model battery storage requirements.

"Find the single electric meter with the highest usage on the East Coast campus. Pull its 15-minute interval data for July, and tell me what time of day it consistently hits peak demand."

1. Identify the Target Meter: ChatGPT calls list_all_arcadia_plug_meters, using query parameters to filter for the "East Coast campus" site and serviceType=electric.
2. Fetch Interval Data: The agent takes the resulting meter ID and calls get_single_arcadia_normalized_intervals_meter_by_id, specifically setting startAt to July 1st and endAt to July 31st.
3. Analyze the Time-Series Array: The LLM ingests the massive array of 15-minute readings, processes the raw values, and mathematically determines that peak usage consistently occurs between 2:15 PM and 3:30 PM on weekdays.

Security and Access Control

Exposing sensitive enterprise energy data and utility credentials to an LLM requires strict governance. Truto's MCP architecture enforces security at the infrastructure layer, independent of the LLM's instructions.

• Method Filtering: You can strictly limit an MCP server to read-only access. By setting methods: ["read"] during token generation, the server will block any attempts by the AI agent to execute create, update, or delete tools, preventing accidental data modification.
• Tag-Based Scoping: If you only want the LLM to access meter data but not financial statements, you can apply tag filters during server creation so only meter tagged resources are exposed as tools.
• Time-to-Live (TTL): Temporary MCP servers can be generated with an expires_at timestamp. Once the expiration time passes, Truto automatically purges the token from the database and edge KV storage, immediately cutting off access.
• Dual-Layer Authentication: By enabling require_api_token_auth, Truto forces the connecting MCP client to provide a valid Truto API token in the headers alongside the server URL. This ensures that a leaked URL is functionally useless without secondary authorization.

Architecting for Scale

Connecting Arcadia to ChatGPT shifts utility data management from manual spreadsheets to conversational intelligence. Instead of dedicating engineering sprints to building custom polling logic and mapping interval schemas, teams can leverage Truto's dynamic MCP server generation to get instant, secure access to the Arcadia API.

Because Truto handles the protocol translation, standardizes rate limit headers, and manages the OAuth credentials under the hood, your engineering team can focus on orchestrating complex AI workflows rather than maintaining infrastructure.