---
title: "Connect Exact Online to Claude: Sync Inventory, Stock & Manufacturing"
slug: connect-exact-online-to-claude-sync-inventory-stock-manufacturing
date: 2026-11-01
author: Yuvraj Muley
categories: ["AI & Agents"]
excerpt: "A definitive engineering guide to connecting Exact Online to Claude via an MCP server to automate inventory, manufacturing, and stock workflows."
tldr: "Learn how to build and configure a managed MCP server for Exact Online to give Claude read/write access to inventory, shop orders, and sales data without maintaining custom API integration code."
canonical: https://truto.one/blog/connect-exact-online-to-claude-sync-inventory-stock-manufacturing/
---

# Connect Exact Online to Claude: Sync Inventory, Stock & Manufacturing


If you need to connect Exact Online to Claude to automate inventory allocation, manage shop orders, or streamline warehouse logistics, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). This server acts as the translation layer between Claude's tool calls and Exact Online's complex REST APIs. You can either [build and maintain this infrastructure yourself](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/), or use a [managed integration platform like Truto](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) to dynamically generate a secure, authenticated MCP server URL. 

If your team uses ChatGPT, check out our guide on [connecting Exact Online to ChatGPT](https://truto.one/connect-exact-online-to-chatgpt-manage-sales-crm-project-data/) or explore our broader architectural overview on [connecting Exact Online to AI Agents](https://truto.one/connect-exact-online-to-ai-agents-automate-finance-payroll-hr/).

Giving a Large Language Model (LLM) read and write access to a sprawling ERP and accounting ecosystem like Exact Online is a serious engineering challenge. You have to handle OAuth 2.0 token lifecycles, manage dynamic division IDs, map OData JSON schemas to MCP tool definitions, and deal with Exact Online's strict API quotas. Every time Exact updates an endpoint or deprecates a legacy data model, 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 Exact Online, connect it natively to Claude Desktop, and execute complex supply chain and manufacturing workflows using natural language.

> Want to give your AI agents secure, authenticated access to Exact Online and 100+ other SaaS APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Exact Online 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 Exact Online's APIs is painful. You are not just integrating a simple REST API - you are interfacing with a massive, highly normalized OData architecture that powers multi-company ERP systems.

If you decide to build a custom Exact Online MCP server, here are the specific integration challenges you will face:

**Mandatory Division Routing**
Almost every endpoint in the Exact Online API requires a `division` ID in the URL path (e.g., `/api/v1/{division}/inventory/ItemWarehouses`). A single Exact Online user might have access to multiple divisions (companies or branches). An LLM has no inherent context on which division to use. Your MCP server must inject the correct division ID into the API path for every tool call based on the authenticated context, hiding this complexity from Claude to prevent hallucinated URLs.

**OData Pagination and Cursors**
Exact Online handles large datasets (like bulk inventory lists) using OData-style pagination. Instead of standard `page` and `limit` parameters, the API returns a `__next` link containing a deeply nested URL with skip tokens. By default, Exact caps responses at 60 rows per page. If your AI agent needs to retrieve a full stock report, it must parse and follow these `__next` cursors iteratively. Truto handles this by normalizing Exact's pagination into standard `limit` and `next_cursor` flat parameters, instructing the LLM to pass cursors back unchanged.

**Rate Limits and 429 Handling**
Exact Online enforces strict rate limits (typically minutely and daily caps) that are dynamically returned in API headers. **It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors.** When Exact Online returns an HTTP 429, Truto passes that error directly to the caller. However, Truto does normalize the upstream rate limit information into standardized IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). Your client application (or Claude's underlying retry logic) is completely responsible for handling the backoff strategy when limits are hit.

## Creating the Exact Online MCP Server

To bridge Claude and Exact Online, you need to generate an MCP server URL scoped to a specific Exact Online account. Truto allows you to generate this dynamic server using either the web UI or the REST API.

### Method 1: Via the Truto UI

For ad-hoc agent testing and internal automation, the Truto dashboard provides a point-and-click interface to generate MCP URLs.

1. Navigate to the **Integrated Accounts** page in your Truto dashboard and select your connected Exact Online account.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration. You can filter by methods (e.g., read-only) or tags (e.g., logistics, inventory) to limit the tools the LLM can access.
5. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API

For production applications, you will want to generate these servers programmatically. By making a `POST` request to `/integrated-account/:id/mcp`, Truto generates a cryptographically secure token stored in low-latency KV infrastructure.

```bash
curl -X POST https://api.truto.one/api/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Exact Online Supply Chain Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["inventory", "production", "wms"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

This API call dynamically builds the tool definitions based on the Exact Online integration schemas and returns a ready-to-use URL that requires no further authentication on the client side.

## Connecting the MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude takes less than a minute. You can configure this via the Claude UI or through a manual configuration file.

### Method A: Via the Claude UI

If you are using Claude's web interface or a platform that supports UI-based MCP configuration (like ChatGPT's advanced settings):

1. In Claude, navigate to **Settings → Integrations → Add MCP Server**.
2. Paste your Truto MCP URL.
3. Click **Add**. Claude will instantly send an `initialize` request to Truto, fetching the full suite of Exact Online tools.

### Method B: Via Manual Configuration File

If you are running Claude Desktop locally or configuring an agentic framework programmatically, you can add the server to your `claude_desktop_config.json` file. Because Truto MCP servers use HTTP POST for JSON-RPC 2.0 communication (Server-Sent Events), you use the official MCP SSE transport module.

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

Restart Claude Desktop. When you start a new conversation, you will see the Exact Online tools populated in Claude's tool menu.

## Exact Online Hero Tools for Claude

Truto automatically generates highly descriptive snake_case tools from Exact Online's underlying OData endpoints. Because all input arguments are flattened into a single JSON schema, Claude can effortlessly map natural language to the correct query parameters and request bodies. 

Here are the highest-leverage tools for automating inventory, stock, and manufacturing workflows in Exact Online.

### 1. `list_all_exact_online_stock_position`

Retrieve item stock levels and projected stock levels based on planned movements (sales orders, shop orders, purchase orders). This is the foundational tool for AI agents managing supply chains.

> "Claude, check our current stock position for item SKU 'WHEEL-001' and tell me if our projected stock is sufficient to cover our open sales orders."

### 2. `list_all_exact_online_items`

Read the master item catalog. This tool allows the LLM to map natural language product names to exact Item IDs, Unit Codes, and pricing details required for subsequent manufacturing and sales operations.

> "Find the exact Item ID and default warehouse location for the 'Industrial Steel Bearings' in our catalog."

### 3. `create_a_exact_online_warehouse_transfer`

Trigger a draft warehouse transfer. When stock is low in an active distribution center, Claude can use this tool to stage inventory movements from a primary holding facility.

> "Create a warehouse transfer moving 500 units of item 'BOX-05' from the Main Warehouse to the Retail Fulfillment Center. Set the entry date for tomorrow."

### 4. `create_a_exact_online_shop_order`

Create an order to manufacture (make) an item. This initiates the production lifecycle in Exact Online, allocating the required components based on the Bill of Materials (BOM) linked to the item.

> "We need to restock our custom bicycles. Create a shop order for 50 units of item 'BIKE-PRO-X' and assign it to the assembly department."

### 5. `list_all_exact_online_sales_orders`

Retrieve current sales orders to evaluate demand. Claude can filter these by status to determine which items need to be rushed in production or prioritized for dropshipping.

> "List all open sales orders from the past week that include item 'BATTERY-PACK'. Are there any orders pending fulfillment?"

### 6. `create_a_exact_online_goods_delivery`

Process the delivery of goods for a sales order. This tool allows the LLM to complete the fulfillment cycle, adjusting actual stock quantities down once items are confirmed shipped.

> "Process a goods delivery for Sales Order ID 'ORD-99120'. Mark the delivery date as today and confirm the quantity delivered matches the order."

To view the comprehensive inventory of tools available for Exact Online—including HRM, financial accounting, and CRM operations—visit the [Exact Online integration page](https://truto.one/integrations/detail/exactonline).

## Workflows in Action

MCP tools are most powerful when chained together. Because Truto flattens the query and body schemas, Claude can easily extract IDs from one tool response and pass them as payload parameters to the next. 

Here are two concrete examples of how Claude executes domain-specific Exact Online supply chain workflows.

### Workflow 1: Automated Manufacturing Restock

When a sales representative notices low inventory on a popular manufactured product, they can ask Claude to evaluate the situation and kick off production if necessary.

> "Check the stock position for 'Custom Drone Frame v2'. If the projected stock is below 10 units, create a new shop order to manufacture 25 more units."

**How the agent executes this:**

1. **Find the Item ID:** Claude calls `list_all_exact_online_items` with a query for "Custom Drone Frame v2" to retrieve the Exact Online `ItemID`.
2. **Check Stock Position:** Claude calls `list_all_exact_online_stock_position` using the extracted `itemId`. 
3. **Evaluate Logic:** Claude analyzes the JSON response, specifically looking at the projected stock level.
4. **Create Shop Order:** Seeing the stock is at 4 units, Claude calls `create_a_exact_online_shop_order`, passing the `ItemID` and `PlannedQuantity: 25` into the body schema.

```mermaid
sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant Exact as Exact Online API

    User->>Claude: "Restock Custom Drone Frame v2 if < 10"
    Claude->>MCP: Call list_all_exact_online_items
    MCP->>Exact: GET /api/v1/{div}/logistics/Items
    Exact-->>MCP: Return ItemID
    MCP-->>Claude: Return ItemID
    
    Claude->>MCP: Call list_all_exact_online_stock_position
    MCP->>Exact: GET /api/v1/{div}/read/logistics/StockPosition
    Exact-->>MCP: Stock = 4
    MCP-->>Claude: Stock = 4
    
    Claude->>MCP: Call create_a_exact_online_shop_order (Qty: 25)
    MCP->>Exact: POST /api/v1/{div}/manufacturing/ShopOrders
    Exact-->>MCP: Shop Order Created (201)
    MCP-->>Claude: Success Confirmation
    Claude-->>User: "Shop order for 25 units has been created."
```

### Workflow 2: Warehouse Transfer for Sales Fulfillment

When sales outpace local warehouse inventory, Claude can audit open sales orders and stage warehouse transfers to ensure timely fulfillment.

> "Find all open sales orders for 'Premium Coffee Beans'. Check the stock in the 'East Coast Hub'. If it can't cover the open orders, stage a warehouse transfer from the 'Central Distribution' warehouse to cover the deficit."

**How the agent executes this:**

1. **Fetch Open Orders:** Claude calls `list_all_exact_online_sales_orders` filtering by the item description to calculate total pending demand (e.g., 200 units).
2. **Audit Local Inventory:** Claude calls `list_all_exact_online_item_warehouse_storage_locations` to check the exact stock of coffee beans in the East Coast Hub (e.g., 50 units).
3. **Calculate Deficit:** The model calculates a deficit of 150 units.
4. **Execute Transfer:** Claude calls `create_a_exact_online_warehouse_transfer` passing `WarehouseFrom` (Central), `WarehouseTo` (East Coast), and injecting `create_a_exact_online_warehouse_transfer_line` data for the 150 units required.

## Security and Access Control

Giving AI models write access to an ERP requires strict governance. Truto MCP servers are highly configurable, ensuring that your agents only interact with the exact endpoints they need.

*   **Method Filtering:** Enforce read-only access by passing `methods: ["read"]` during server creation. This allows the model to query inventory and sales orders but completely prevents it from executing `create`, `update`, or `delete` operations.
*   **Tag Filtering:** Restrict the server to specific domains. By setting `tags: ["inventory", "wms"]`, you prevent the AI from accidentally accessing Exact Online's HRM, payroll, or financial accounting tools.
*   **Time-to-Live (TTL):** Create ephemeral MCP servers by setting an `expires_at` timestamp. Once expired, Truto's Durable Object alarms automatically clean up the database records and KV entries, revoking access immediately.
*   **Secondary Authentication:** Enable `require_api_token_auth: true`. This requires the client connecting to the MCP URL to also supply a valid Truto API token in the `Authorization` header, adding a strict layer of defense if the MCP URL is ever leaked.

## Summary

Integrating Exact Online with AI agents natively requires navigating complex OData syntax, dynamic division IDs, and rigorous rate limit handling. By leveraging a managed MCP server via Truto, you abstract away the API boilerplate. 

Truto dynamically parses Exact Online's schemas into clean, flat JSON-RPC tools, standardizes rate limit headers, and manages the underlying OAuth lifecycles. This allows your engineering team to focus on prompt engineering and agent architecture, while Claude handles the heavy lifting of inventory, stock, and manufacturing automation.