---
title: "Connect Acumatica to ChatGPT: Manage ERP Records and Attachments"
slug: connect-acumatica-to-chatgpt-manage-erp-records-and-attachments
date: 2026-10-04
author: Yuvraj Muley
categories: ["AI & Agents"]
excerpt: "Learn how to generate a secure MCP server for Acumatica using Truto, connect it to ChatGPT, and automate ERP records, business actions, and file attachments."
tldr: "Connect Acumatica to ChatGPT using Truto's auto-generated MCP server. Skip writing custom integration code and enable AI agents to securely manage ERP records, execute async actions, and handle attachments using natural language."
canonical: https://truto.one/blog/connect-acumatica-to-chatgpt-manage-erp-records-and-attachments/
---

# Connect Acumatica to ChatGPT: Manage ERP Records and Attachments

**Acumatica in ChatGPT, in about a minute.** The best way to connect Acumatica to ChatGPT is Elaichi: connect Acumatica to Elaichi once, then add Elaichi to ChatGPT as a connector. Two steps, about a minute, with a 14-day free trial and no credit card required.

1. **Start your free trial.** Create your Elaichi account. 14 days free, no credit card required.
2. **Connect Acumatica.** Connect Acumatica once in Elaichi. ChatGPT never gets more access than you have.
3. **Add Elaichi to ChatGPT.** In ChatGPT, open Plugins, press +, and paste https://api.elaichi.ai/mcp into Server URL. Sign in and approve.

[Start free on Elaichi, 14 days, no credit card required](https://app.elaichi.ai/signup?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=acumatica) · [Acumatica on Elaichi](https://elaichi.ai/connectors/acumatica/?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=acumatica)

*Building Acumatica into your own product? The guide below is for you.*

---

If you need to connect Acumatica to ChatGPT to automate complex ERP workflows, manage financial records, execute business actions, or handle file attachments, you need a [Model Context Protocol (MCP) server](https://truto.one/blog/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and Acumatica's highly specific Contract-Based REST API.

If your team uses Claude, check out our guide on [connecting Acumatica to Claude](https://truto.one/connect-acumatica-to-claude-run-reports-and-execute-business-actions/) or explore our broader architectural overview on [connecting Acumatica to AI Agents](https://truto.one/connect-acumatica-to-ai-agents-sync-data-files-and-process-actions/).

Giving a [Large Language Model (LLM) read and write access to a modern Cloud ERP](https://truto.one/blog/connect-ai-agents-to-netsuite-sap-via-mcp-the-2026-architecture-guide/) like Acumatica is an immense engineering challenge. You have to navigate dynamic endpoint versions, construct exact JSON payloads for complex nested entities, handle asynchronous polling for business actions, and securely proxy binary file streams for attachments. You can either spend weeks building, hosting, and maintaining this custom integration infrastructure, or you can use a managed platform to [dynamically generate a secure, authenticated MCP server URL](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/).

This guide breaks down exactly how to use Truto to generate a managed MCP server for Acumatica, connect it natively to ChatGPT, and execute complex ERP 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 Acumatica API

A custom MCP server is essentially a self-hosted integration middleware layer. While the [open MCP standard](https://truto.one/blog/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/) provides a predictable way for LLMs to discover tools, implementing it against Acumatica's specific architecture is exceptionally painful.

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

### Contract-Based REST APIs and Endpoint Versioning
Acumatica does not expose a static set of REST endpoints (like `/api/v1/users`). Instead, it uses a "Contract-Based" API where endpoints are defined by custom system configurations. Every API call requires an `endpoint_name`, `endpoint_version`, and the `entity` name. For example, to query Sales Orders, your proxy must dynamically construct paths like `/entity/Default/22.200.001/SalesOrder`. Your MCP server must inject these routing variables securely while exposing a flat tool interface to the LLM. If the ERP administrator updates the endpoint version in Acumatica, static tool schemas will instantly break.

### The "PUT for Create" Quirk
Unlike 99% of modern REST APIs that use `POST` to create records, Acumatica uses `PUT` to create new entity records by sending a JSON representation to the entity's collection path. If your LLM framework or standard HTTP client defaults to standard REST conventions, requests will fail. Furthermore, fields in the JSON body must be nested inside `{ "value": ... }` structures for specific data types, requiring strict JSON schema validation before the payload ever reaches the ERP.

### Asynchronous Business Actions
Acumatica allows clients to invoke business logic (actions) on top-level entities—such as releasing a document or confirming a shipment. However, these endpoints do not return immediate results. They return a `202 Accepted` status code with a `Location` header. The client must then poll this location URL to determine if the async job succeeded or failed. Exposing this to an LLM means either teaching the LLM to write a polling loop, or building a stateful polling mechanism directly into your MCP server.

### Attachment Streaming Complexity
Handling file attachments in Acumatica requires targeting the specific `view` and `field` associated with the record. Fetching an attachment returns raw binary content, not a JSON object. Large Language Models communicate purely in text. Your MCP server must safely proxy this binary data, handle the multi-part form uploads for creating new attachments, and translate file boundaries back into a structure the LLM can acknowledge.

## Step 1: Generating the Acumatica MCP Server

Truto abstracts away the complexity of the Acumatica API by dynamically generating an MCP server based on the ERP's documented resources and your specific configuration. 

Every Acumatica integration in Truto is scoped to an **Integrated Account** (the authenticated connection to the customer's Acumatica instance). The generated MCP server URL contains a cryptographic token that securely maps to this specific connection. 

There are two ways to generate this server.

### Method A: Via the Truto UI

For quick prototyping or manual setup:

1. Log into your Truto dashboard and navigate to the **Integrated Accounts** section.
2. Select your connected Acumatica account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Configure the server. You can name it (e.g., "ChatGPT Acumatica Server") and apply filters. For example, select the `methods` dropdown to restrict the server to `read` operations only if you want a read-only agent.
6. Click **Create** and copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/a1b2c3d4e5f6...`). Treat this URL as a secure credential.

### Method B: Via the API

For production use cases where you need to [programmatically provision AI agents for your customers](https://truto.one/blog/how-to-architect-a-multi-tenant-mcp-server-for-enterprise-b2b-saas/), you can generate the MCP server via Truto's REST API.

Make a `POST` request to `/integrated-account/:id/mcp`, passing in the configuration payload to scope the tools.

```bash
curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Acumatica ERP Operations Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["erp", "sales", "inventory"]
    }
  }'
```

The API responds with the tokenized endpoint. This URL handles protocol wrapping, token resolution, and dynamic tool generation on the fly.

```json
{
  "id": "mcp_abc123",
  "name": "Acumatica ERP Operations Agent",
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

## Step 2: Connecting the MCP Server to ChatGPT

Once you have the Truto MCP URL, connecting it to ChatGPT requires zero additional code. 

### Method A: Via the ChatGPT UI (Developer Mode)

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education accounts, you can add the server natively:

1. Open ChatGPT and navigate to **Settings → Apps → Advanced settings**.
2. Toggle **Developer mode** to ON.
3. Under the **MCP servers / Custom connectors** section, click **Add new server**.
4. **Name:** Enter a descriptive name (e.g., "Acumatica ERP").
5. **Server URL:** Paste the Truto MCP URL (`https://api.truto.one/mcp/...`).
6. Click **Save**.

ChatGPT will immediately perform a handshake with the Truto server, execute the `tools/list` JSON-RPC method, and load the Acumatica tools into its context window.

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

If you are running a local agent, using an alternative client, or leveraging the official `@modelcontextprotocol/server-sse` package, you can define the server in your MCP configuration file (`mcp.json` or `claude_desktop_config.json` equivalent):

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

## Hero Tools for Acumatica

Truto automatically maps Acumatica's endpoints into descriptive, snake_case tools that ChatGPT understands. Because LLMs struggle with complex object nesting, Truto flattens the query arguments while securely mapping them to the expected API parameters at runtime.

Here are the highest-leverage tools available for Acumatica operations. For the complete list of tools and JSON schemas, view the [Acumatica integration page](https://truto.one/integrations/detail/acumatica).

### list_all_acumatica_records
Lists records for any specified Acumatica entity (e.g., `SalesOrder`, `Customer`, `InventoryItem`). Supports `$filter`, `$select`, and `$expand` to precisely shape the data retrieved and avoid bloating the LLM's context window. 

> "Fetch the last 5 SalesOrders created this month using endpoint version 22.200.001. Expand the Details property so I can see the line items."

### create_a_acumatica_entity_record
Creates a new record for an entity. Truto abstracts the underlying Acumatica `PUT` quirk, allowing the LLM to simply pass the JSON structure for the entity. System fields like `id` and `rowNumber` are automatically handled in the response.

> "Create a new Customer record in Acumatica for 'Acme Corp'. Ensure the CustomerClass is set to 'DEFAULT' and format the data using the endpoint version 22.200.001."

### update_a_acumatica_record_by_id
Updates an existing record. Acumatica relies heavily on specific ID fields and keys. The tool schema strictly enforces the required identifiers, reducing hallucinated update requests.

> "Update the SalesOrder with ID 'SO-000142'. Change the Status to 'On Hold' and add a note explaining that the customer requested a delay."

### acumatica_actions_execute_action
Invokes an action on a top-level entity, such as releasing an invoice or confirming a shipment. Because this triggers Acumatica's async processor, it returns a 202 Accepted status. The LLM must be instructed to monitor or note the resulting polling URL.

> "Execute the 'Release' action on Invoice ID 'INV-9923'. Pass the necessary parameters for the action payload using endpoint Default version 22.200.001."

### list_all_acumatica_attachments
Lists all files attached to a specific Acumatica record, addressed by its data view and field. Crucial for auditing or verifying documentation linked to ERP entities.

> "List all the files attached to the ExpenseReceipt record 'ER-505'. I need to see the filenames and href links to verify the physical receipts were uploaded."

### create_a_acumatica_attachment
Uploads binary file content and attaches it to an Acumatica record via the specified view and field. The tool handles the file boundaries and multipart structure.

> "Attach the provided vendor contract PDF to Vendor record 'V-0112'. Add the comment 'Signed SLA 2026' to the attachment metadata."

For the full list of available operations, required parameters, and JSON schemas, visit the [Acumatica integration page](https://truto.one/integrations/detail/acumatica).

## Workflows in Action

Connecting an LLM to an ERP isn't just about reading data; it's about executing multi-step business logic safely. Here are two real-world scenarios showing how ChatGPT orchestrates these tools.

### Scenario 1: Releasing a Sales Order (Sales Operations)

A sales representative wants to finalize a stalled order and push it through the ERP state machine using natural language.

> "Check the status of Sales Order 'SO-54321'. If the status is 'Open' and the hold flag is removed, execute the action to 'Release' the order."

```mermaid
sequenceDiagram
    participant User
    participant Agent as ChatGPT
    participant Truto as Truto MCP Server
    participant API as Acumatica API

    User->>Agent: "Check SO-54321, if Open, Release it."
    
    Agent->>Truto: Call `get_single_acumatica_record_by_id` (SO-54321)
    Truto->>API: GET /entity/Default/22.200.001/SalesOrder/SO-54321
    API-->>Truto: JSON (Status: Open, Hold: False)
    Truto-->>Agent: Returns flattened order details
    
    Agent->>Truto: Call `acumatica_actions_execute_action` (Action: Release)
    Truto->>API: POST /entity/Default/22.200.001/SalesOrder/Release
    API-->>Truto: 202 Accepted (Location: /status/job-123)
    Truto-->>Agent: Returns async job status
    
    Agent-->>User: "The order is Open and off hold. I have triggered the Release action. The job is currently processing."
```

**What happens:** ChatGPT first retrieves the record to verify the business logic rules (status and hold flag). Confirming the order is ready, it automatically formats the payload for the `acumatica_actions_execute_action` tool. It understands the 202 response and correctly informs the user that the background job has been triggered.

### Scenario 2: Auditing Expense Attachments (Accounting)

An accountant needs to verify that physical receipts are attached to high-value expense claims.

> "Find all Expense Receipts created today over $500. For each one, check if there are any attachments. If an attachment is missing, flag the receipt ID for review."

```mermaid
sequenceDiagram
    participant User
    participant Agent as ChatGPT
    participant Truto as Truto MCP Server
    participant API as Acumatica API

    User->>Agent: "Find expenses >$500 today, verify attachments."
    
    Agent->>Truto: Call `list_all_acumatica_records` ($filter: Amount gt 500, Date eq Today)
    Truto->>API: GET /entity/Default/22.200.001/ExpenseReceipt?$filter=...
    API-->>Truto: JSON (Receipt array: ER-101, ER-102)
    Truto-->>Agent: Returns receipt list
    
    Agent->>Truto: Call `list_all_acumatica_attachments` (Record: ER-101)
    Truto->>API: GET /entity/Default/22.200.001/ExpenseReceipt/ER-101/files
    API-->>Truto: JSON (1 attachment)
    Truto-->>Agent: Returns file metadata
    
    Agent->>Truto: Call `list_all_acumatica_attachments` (Record: ER-102)
    Truto->>API: GET /entity/Default/22.200.001/ExpenseReceipt/ER-102/files
    API-->>Truto: JSON (0 attachments)
    Truto-->>Agent: Returns empty list
    
    Agent-->>User: "ER-102 is missing an attachment and has been flagged. ER-101 is compliant."
```

**What happens:** The LLM leverages OData filtering on the `list_all_acumatica_records` tool to pull a targeted dataset. It then iterates through the returned IDs, invoking the attachment list tool for each. It acts as an autonomous auditor, parsing the JSON arrays and summarizing the compliance gaps perfectly.

## Security and Access Control

Exposing an ERP like Acumatica to an AI agent demands strict security controls. The Truto MCP server allows you to tightly scope what ChatGPT can do:

*   **Method Filtering:** Configure `config.methods: ["read"]` to ensure the MCP server only exposes `GET` and `LIST` tools. This creates a completely safe, read-only agent that cannot alter financial records.
*   **Tag Filtering:** Use `config.tags: ["sales", "inventory"]` to restrict the server tools to specific domain areas, ensuring an inventory management agent cannot access HR or payroll endpoints.
*   **API Token Authentication:** For enterprise deployments, enable `require_api_token_auth: true`. This forces the client to pass a valid Truto API token in addition to possessing the MCP URL, securing the endpoint against URL leakage.
*   **Time-to-Live (TTL):** Set an `expires_at` timestamp when creating the server. Truto will automatically destroy the server and its underlying KV records at the specified time, perfect for temporary audit access.

## Handling Rate Limits and API Errors

AI agents can generate requests much faster than humans, making rate limiting a critical concern. 

Truto does not absorb, retry, or apply backoff to rate limit errors. If the underlying Acumatica instance triggers a rate limit (HTTP 429), Truto passes that error directly back to the caller. 

However, Truto normalizes the upstream rate limit information into standard IETF HTTP headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). This allows the LLM client (or your orchestration layer) to read the exact timestamp of when the limit resets and implement intelligent backoff strategies without having to parse Acumatica-specific error payloads.

## Stop Building Integration Boilerplate

Building a custom integration layer between an LLM and a complex ERP like Acumatica requires weeks of writing API wrappers, managing authentication flows, mapping JSON schemas, and fighting with undocumented edge cases.

By leveraging Truto, you bypass the infrastructure overhead. The dynamic documentation-driven architecture ensures that as the Acumatica API evolves, your MCP tools adapt automatically. You get secure, scoped, and managed toolsets that connect natively to ChatGPT, allowing your engineering team to focus on AI orchestration instead of API maintenance.

> 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/)