---
title: "Connect Arcadia to Claude: Sync Meter Data and Statements"
slug: connect-arcadia-to-claude-sync-meter-data-and-statements
date: 2026-06-19
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Arcadia to Claude using a managed MCP server. Sync utility meters, automate statement retrieval, and handle async CSV downloads."
tldr: "Connect Arcadia to Claude via Truto's managed MCP server. This guide details how to handle Arcadia's async polling requirements, generate tools, and build energy data workflows."
canonical: https://truto.one/blog/connect-arcadia-to-claude-sync-meter-data-and-statements/
---

# Connect Arcadia to Claude: Sync Meter Data and Statements


If you need to connect Arcadia to Claude to sync utility meter intervals, process energy statements, or automate sustainability reporting, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between Claude'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 ChatGPT, check out our guide on [connecting Arcadia to ChatGPT](https://truto.one/connect-arcadia-to-chatgpt-analyze-utility-bills-and-usage/) or explore our broader architectural overview on [connecting Arcadia to AI Agents](https://truto.one/connect-arcadia-to-ai-agents-automate-utility-data-pipelines/).

Giving a Large Language Model (LLM) read and write access to an enterprise utility data platform like Arcadia is an engineering challenge. You have to handle credential lifecycles, map massive JSON schemas for interval data to MCP tool definitions, and deal with Arcadia's highly specific async job patterns. 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 Claude, and execute complex 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](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) provides a predictable way for models to discover tools, the reality of implementing it against Arcadia's APIs is painful. You are not just integrating a standard CRUD API - you are integrating a complex utility data pipeline that bridges physical grid infrastructure with digital records.

If you decide to build a custom MCP server for Arcadia, you own the entire API lifecycle. Here are the specific challenges you will face:

**Two-Step Asynchronous Downloads**
Arcadia rarely serves massive datasets like meter intervals or bulk statement summaries synchronously. Instead, it uses a two-step process. First, you POST a request containing up to 500 meter IDs. Arcadia returns a `202 Accepted` with a URL or webhook ID. You then have to poll a secondary endpoint to stream the file. LLMs struggle immensely with unguided polling. If you just expose the raw endpoints, Claude will either invent a webhook ID or hallucinate the CSV contents. Truto's doc-driven schemas explicitly instruct Claude on how to parse the initial token, wait, and use it in the subsequent polling tool.

**Complex Hierarchical Data Models**
Arcadia's data model is deeply nested: Organizations have Sites, Sites have Accounts, Accounts have Meters and Statements, and Meters have Intervals. When an LLM wants to pull interval data for a building, it first needs to navigate this hierarchy. Truto exposes this via flat proxy operations with clear query parameters, allowing the LLM to traverse the utility topology without needing to understand the underlying graph structure.

**Strict Rate Limits and 429 Passthrough**
Arcadia enforces strict API quotas, especially on heavy endpoints like interval data extraction. If Claude gets stuck in a loop trying to iterate over 10,000 meters, it will hit a wall. Truto does not retry, throttle, or apply backoff on rate limit errors. Instead, when Arcadia returns an HTTP `429 Too Many Requests`, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. This explicit passthrough is critical for AI agents - Claude needs to receive the `429` directly so it can implement its own reasoning to pause, wait for the reset window, and retry the operation.

## How to Generate an Arcadia MCP Server with Truto

Truto dynamically generates MCP tools based on Arcadia's API resources and documentation. When you connect an Arcadia account for a specific tenant (creating an "Integrated Account"), you can spin up an MCP server scoped entirely to that tenant. Truto reads the available API endpoints, pulls the query and body schemas, injects necessary pagination logic, and serves them over a JSON-RPC 2.0 endpoint.

You can generate the MCP server using either the Truto UI or the API.

### Method 1: Via the Truto UI

This is the fastest method for manual setup or testing.

1. Navigate to the **Integrated Accounts** page in your Truto dashboard and select the connected Arcadia account.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Configure the server. You can optionally restrict it to specific operations (e.g., `read` only) or specific tags (e.g., `meters`, `statements`).
5. Click **Create** and copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/abc123def456...`).

### Method 2: Via the Truto API

For teams building multi-tenant AI products, you should automate server creation. Make a `POST` request to the Truto API using your environment token.

```bash
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": "Arcadia Meter Analyzer",
    "config": {
      "methods": ["read", "list"],
      "tags": ["meters", "intervals", "statements"]
    }
  }'
```

The API validates that the Arcadia integration has documented tools available, securely hashes the token, and returns a ready-to-use URL:

```json
{
  "id": "mcp_srv_89101112",
  "name": "Arcadia Meter Analyzer",
  "config": {
    "methods": ["read", "list"],
    "tags": ["meters", "intervals", "statements"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8..."
}
```

This URL is fully self-contained. It encodes the tenant routing and handles the OAuth lifecycle automatically. 

## How to Connect Arcadia to Claude

Once you have your Truto MCP server URL, you must connect it to your Claude environment. You can do this through the Claude Desktop UI or via configuration files for custom agent setups.

### Method A: Via the Claude Desktop UI

If you are using Claude Desktop for local workflows:

1. Open Claude Desktop.
2. Go to **Settings** -> **Integrations** -> **Add MCP Server**.
3. Paste the Truto MCP URL into the connection field.
4. Click **Add**.

Claude will immediately execute an `initialize` handshake and call `tools/list`. The model will now have native access to the Arcadia tools.

*(Note: If your team uses ChatGPT Enterprise, you can follow a similar path: [Settings -> Apps -> Advanced settings -> enable Developer mode](https://truto.one/connect-arcadia-to-chatgpt-analyze-utility-bills-and-usage/), and add the server URL under Custom Connectors).* 

### Method B: Via Manual Config File (SSE Transport)

If you are deploying Claude via a programmatic setup, CLI, or an environment like Cursor, you connect via Server-Sent Events (SSE) using the official `@modelcontextprotocol/server-sse` package.

Modify your `claude_desktop_config.json` (or equivalent framework config) to point to the Truto URL:

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

Restart your client. The agent will fetch the tools and make them available for function calling.

## Hero Tools for Arcadia

Arcadia has a massive API surface area. Truto exposes dozens of endpoints, but these are the high-leverage "hero" operations that AI agents use most frequently when dealing with utility data.

### List All Accounts Details
Retrieves detailed information across the Arcadia system for the tenant, including status, meter counts, provider metadata, and gap summaries.

> "Fetch a list of all active Arcadia accounts and filter for accounts that have a gap summary indicating missing statements. Return their account numbers and provider names."

### List All Arcadia Plug Meters
Lists all meters retrieved from utility providers. This is the starting point for any usage or interval analysis.

> "Find all electric meters associated with site ID 'site_889900'. I need the meter numbers, their current status, and the service type."

### Prepare Intervals CSV Download
Initiates the first step of Arcadia's async 2-step process for retrieving meter interval data. It takes up to 500 meter IDs and returns a URL token.

> "I need the 15-minute interval usage data for the following three meter IDs: 'm_111', 'm_222', and 'm_333'. Initiate the interval download request and give me the tracking ID."

### Stream Download Sources
Executes the second step of the async download. You pass the token generated from the interval or statement prep tools, and it polls for the finished CSV stream.

> "Check the status of the download request webhook ID 'wh_888999'. If it returns a 200 OK, parse the CSV and summarize the peak usage times."

### List Detailed Statements
Retrieves granular statement metadata across the account, including statement dates, total charges, outstanding balances, and due dates.

> "Pull the detailed statements for account 'acc_555' over the last 6 months. Calculate the total amount billed and highlight any outstanding balances."

### Download Statement Source File
Retrieves the actual binary PDF file stream for a specific utility statement, which can then be processed by Claude's vision or document parsing capabilities.

> "Download the source PDF for statement ID 'stmt_12345' and extract the line-item charges for transmission and distribution."

For the complete tool inventory, including webhook management, organization custom data updates, and credential lifecycle tools, see the [Arcadia integration page](https://truto.one/integrations/detail/arcadia).

## Workflows in Action

MCP servers don't just execute single endpoints; they allow Claude to orchestrate complex, multi-step processes across the Arcadia ecosystem autonomously. Here is what that looks like in practice.

### Scenario 1: Demand Response Modeling
An energy analyst needs to identify the peak load hours for a commercial building to evaluate it for a demand response program.

> "Find all electric meters for the 'Downtown Office' site. Pull their interval data for the month of July. Analyze the CSV and tell me which 4-hour window consistently hits the highest kW demand."

**How Claude executes this:**
1.  Calls `list_all_arcadia_plug_sites` with a search filter for "Downtown Office" to retrieve the site ID.
2.  Calls `list_all_arcadia_plug_meters` filtering by the discovered site ID and service type (electric) to gather an array of meter IDs.
3.  Calls `create_a_arcadia_downloads_interval` with the meter IDs to trigger the backend data extraction, receiving a webhook ID.
4.  Enters a polling loop calling `list_all_arcadia_download_sources` with the webhook ID. If it hits a `202 Pending`, it waits. Once it gets a `200 OK`, it parses the returned CSV stream.
5.  Analyzes the normalized interval values and summarizes the peak load periods.

### Scenario 2: Automated Statement Reconciliation
A finance operator needs to reconcile outstanding utility balances against raw vendor invoices.

> "Find any statements with an outstanding balance greater than $500. For each one, download the source PDF, read the line items, and verify if there are any unexpected late fees or adjustments."

**How Claude executes this:**
1.  Calls `list_all_arcadia_statements_details` to retrieve recent statement metadata.
2.  Filters the JSON array internally to isolate records where `outstandingBalance` is > 500.
3.  For each matching record, extracts the `statement_id`.
4.  Calls `arcadia_sources_list_4` with the `statement_id` to download the raw utility bill PDF.
5.  Reads the PDF content, extracts the line items, and compares the raw invoice data against the expected charges.

## Security and Access Control

When connecting powerful AI agents to production utility data, security is paramount. Truto's MCP architecture provides strict controls to ensure agents only access what they need.

*   **Tenant Isolation**: Every MCP server URL is cryptographically tied to a single integrated Arcadia account. Cross-tenant data leakage is structurally impossible at the API layer.
*   **Method Filtering**: You can configure the MCP token (via `config.methods`) to allow only read operations. If you pass `["read"]` during creation, endpoints that create, update, or delete Arcadia resources will be completely stripped from the schema before Claude even sees them.
*   **Tag Filtering**: You can limit the server to specific resource domains. Passing `config.tags = ["meters", "statements"]` ensures the LLM cannot access or modify credentials or webhook configurations.
*   **Time-to-Live (TTL)**: By setting an `expires_at` timestamp when creating the MCP server, you can generate temporary access credentials. Once expired, the server automatically self-destructs and the token is flushed from edge KV storage.
*   **Require API Token Auth**: For internal enterprise deployments, you can set `require_api_token_auth: true`. This forces the client to pass a valid Truto session token or API key in addition to the URL token, providing defense in depth.

## Moving Past Manual Utility Pipelines

Connecting Claude to Arcadia via MCP changes how organizations interact with utility data. Instead of building rigid ETL pipelines that dump flat files into a data warehouse, you give reasoning engines direct access to the source of truth. They can traverse the grid topology, trigger asynchronous interval jobs, parse complex PDF statements, and gracefully back off when they hit the vendor's rate limits.

By using Truto to generate your MCP servers, you bypass the boilerplate. You don't have to write custom polling wrappers, handle OAuth token refreshes, or maintain brittle OpenAPI specifications. You generate a secure URL, hand it to Claude, and let the agent do the work.

> Stop writing custom API wrappers for AI agents. Let Truto generate secure, doc-driven MCP servers for your entire integration stack.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)