Connect Cin7 Core to Claude: Sync Inventory & Logistics via MCP

If you need to connect Cin7 Core to Claude to automate inventory replenishment, track advanced purchase orders, or orchestrate cross-warehouse logistics, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Cin7 Core's strict, accounting-centric 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 Cin7 Core to ChatGPT or explore our broader architectural overview on connecting Cin7 Core to AI Agents.

Giving a Large Language Model (LLM) read and write access to a complex ERP and inventory management system like Cin7 Core (formerly DEAR Systems) is a massive engineering undertaking. You have to handle rigid authentication lifecycles, map deeply nested JSON payloads to MCP tool definitions, and deal with strict transactional state requirements. Every time an API operation fails due to inventory locks or validation rules, your integration needs to bubble that error up clearly to the LLM so it can correct its payload.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Cin7 Core, connect it natively to Claude Desktop, and execute complex supply chain workflows using natural language.

The Engineering Reality of the Cin7 Core 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 specialized ERP APIs is brutal. Cin7 Core enforces strict accounting and supply chain rules at the API level. If you decide to build a custom Cin7 Core MCP server, here are the specific integration challenges you will face:

Deprecated Endpoints and Fragmented Workflows Cin7 Core's API maintains older endpoints for backward compatibility while forcing new integrations to use upgraded architectures. For example, create_a_cin_7_core_purchase supports only "Simple Purchases" and is officially deprecated. If you dump a raw OpenAPI spec into an LLM, it will frequently attempt to use these legacy endpoints, resulting in failed calls when trying to process complex workflows like freight allocation or staged receiving. You must build an abstraction layer that explicitly guides Claude to use the modern create_a_cin_7_core_advanced_purchase endpoint.

Deeply Nested Transactional States Cin7 Core doesn't just let you update a sale status from "Pending" to "Shipped". A sale is a parent object containing embedded arrays for Quotes, Orders, Fulfilment Picks, Fulfilment Packs, and Fulfilment Ships. To fulfill an order, an LLM must sequence three distinct API calls (create_a_cin_7_core_fulfilment_pick, create_a_cin_7_core_fulfilment_pack, create_a_cin_7_core_fulfilment_ship), passing the exact TaskID and line-item identifiers between them. Missing a single transition leaves the order locked in a draft state.

Unforgiving Rate Limits (And Why You Must Handle Them) Cin7 Core heavily throttles API requests based on concurrent connections and rolling windows. Truto takes a strict architectural stance here: we do not retry, throttle, or apply backoff on rate limit errors. When the upstream Cin7 Core API returns an HTTP 429, Truto passes that exact error to the caller, normalizing the upstream info into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). Your MCP client or agent framework (like LangChain) is entirely responsible for detecting these 429s, reading the ratelimit-reset header, and applying backoff. Do not build an MCP server expecting the proxy to silently absorb rate limits.

Step 1: Generating the Cin7 Core MCP Server via Truto

Instead of hardcoding tool schemas and handling token refreshes manually, Truto derives MCP tools dynamically from the integration's config.resources and documentation records. When you provision an MCP server, Truto returns a single URL containing a cryptographic token. This URL is fully self-contained—it handles authentication, tool generation, and request proxying.

You can create this server in two ways.

Method 1: Via the Truto UI

1. Log into Truto and navigate to the Integrated Accounts page for your Cin7 Core connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., restrict to "read" methods only, or select specific tags like "inventory").
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For automated deployments, you can provision the server programmatically. The API validates that the Cin7 Core integration is AI-ready, generates a hashed token in Cloudflare KV, and returns the endpoint.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Cin7 Core Logistics Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["inventory", "purchasing"]
    }
  }'

Step 2: Connecting the MCP Server to Claude

Once you have the Truto MCP URL, you pass it to Claude. Because Truto's servers speak JSON-RPC 2.0 over HTTP (SSE), no complex middleware is required on the client side.

Method A: Via the Claude UI

If you are using Claude's web interface (or an enterprise workspace that supports custom integrations):

1. In Claude, navigate to Settings → Integrations → Add MCP Server.
2. Name the integration (e.g., "Cin7 Core Production").
3. Paste your Truto MCP URL into the endpoint field and click Add. Claude will immediately call the tools/list JSON-RPC method to parse the available Cin7 Core capabilities.

Method B: Via Manual Config File (Claude Desktop)

For local development and testing with Claude Desktop, you can add the server directly to your configuration JSON file using the official MCP SSE transport tool.

Open ~/Library/Application Support/Claude/claude_desktop_config.json (Mac) or %APPDATA%\Claude\claude_desktop_config.json (Windows) and add:

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

Restart Claude Desktop. The "hammer" icon will appear, indicating that the Cin7 Core tools are loaded and ready to execute.

Hero Tools for Cin7 Core

Truto automatically generates tools for every documented resource on the Cin7 Core API. Because MCP relies on a flat input namespace, Truto automatically merges query parameters and body schemas into a single context for the LLM.

Here are the highest-leverage tools available for your agent. (Note: This is a curated selection. For the complete inventory and exact JSON schemas, view the Cin7 Core Integration Page).

list_all_cin_7_core_products

Searches and retrieves the master product catalog. The LLM can pass query filters like SKU, Name, or ModifiedSince. This is typically step one for any quoting or inventory auditing workflow.

"Check the current stock availability and pricing for all products matching SKU prefix 'WIDGET-2026'. Ensure you include detailed dimensions and reorder levels."

create_a_cin_7_core_advanced_purchase

Creates an advanced purchase order in Cin7 Core. Unlike simple purchases, advanced purchases support complex supply chains including multiple stock receivings and split invoices. The LLM must supply the SupplierID, TaxRule, and BillingAddress.

"Draft a new advanced purchase order for supplier ID 'SUP-908'. Add 500 units of SKU 'WIDGET-2026' and set the status to DRAFT. Assign the shipping location to the East Coast Warehouse."

list_all_cin_7_core_stock_transfers

Retrieves active or historical stock transfers between warehouse locations. The LLM can use this to audit supply chain bottlenecks or verify if inventory has reached its destination.

"Find all stock transfers initiated in the last 7 days that are still marked as 'IN PROGRESS'. List their task IDs and the destination locations."

create_a_cin_7_core_sale_order

Initiates a new sale order against an existing SaleID. The LLM must provide the exact SaleID, a valid Status (either DRAFT or AUTHORISED), and the line items. This is crucial for B2B portal automation.

"I need you to authorize a new sale order under SaleID '98765-ABC'. Add two lines for SKU 'ALPHA-1' and ensure the status is set to AUTHORISED so fulfillment can begin."

create_a_cin_7_core_fulfilment_pack

Generates a Sale Fulfilment Pack record. When transitioning an order to the shipping phase, the agent uses this tool to explicitly define which items are packed into which boxes, moving the fulfilment phase forward.

"Create a fulfillment pack for TaskID 'TASK-1122'. Mark the status as AUTHORISED and include all items from the pick list into a single shipping box."

list_all_cin_7_core_production_orders

Queries manufacturing and production run data. Returns the product info, order status, Bill of Materials (BOM) quantity, and required completion dates. Essential for capacity planning agents.

"Pull the list of all production orders currently sitting in 'WORK IN PROGRESS'. Tell me which ones have a RequiredByDate before next Friday."

Workflows in Action

Once Claude has access to these tools, it can string them together to handle multi-step supply chain operations autonomously.

Scenario 1: Automated Low-Stock Replenishment

User: Supply Chain Manager

"Check our inventory for any products in the 'Electronics' category. If any SKU is below its defined reorder level, draft an advanced purchase order to their respective default suppliers for 200 units each. Do not authorize the POs; leave them as drafts for my review."

How the agent executes this:

1. Calls list_all_cin_7_core_products with a category filter to find electronics and inspects the nested ReorderLevels array.
2. Identifies two SKUs falling below their minimum thresholds and extracts their SupplierID.
3. Calls create_a_cin_7_core_advanced_purchase twice, constructing a JSON payload for each supplier with 200 units, explicitly passing "Status": "DRAFT" to comply with the prompt's constraints.
4. Claude replies with a formatted summary of the drafted purchase orders and their Task IDs for the manager's review.

sequenceDiagram
    participant User
    participant Agent as Claude Desktop
    participant Truto as Truto MCP Router
    participant Cin7 as Cin7 Core API

    User->>Agent: "Check inventory & draft POs..."
    Agent->>Truto: call list_all_cin_7_core_products
    Truto->>Cin7: GET /Products
    Cin7-->>Truto: { SKUs, ReorderLevels, SupplierIDs }
    Truto-->>Agent: JSON schema mapped to text
    Agent->>Truto: call create_a_cin_7_core_advanced_purchase
    Truto->>Cin7: POST /AdvancedPurchase
    Cin7-->>Truto: 200 OK { PurchaseID }
    Truto-->>Agent: Success confirmation
    Agent-->>User: "Drafted 2 POs successfully."

Scenario 2: Orchestrating a Cross-Warehouse Stock Transfer

User: Warehouse Operations Coordinator

"We need to move 50 units of SKU 'BRASS-FITTING-X' from the Downtown Hub to the Northside Facility. Please initiate the stock transfer order and mark it authorized."

How the agent executes this:

1. Calls list_all_cin_7_core_products filtering for SKU=BRASS-FITTING-X to acquire the internal ProductID.
2. Calls list_all_cin_7_core_ref_locations to retrieve the exact internal Location IDs for "Downtown Hub" and "Northside Facility".
3. Calls create_a_cin_7_core_stock_transfer passing the FromLocationID, ToLocationID, the extracted ProductID, a quantity of 50, and setting "Status": "AUTHORISED".
4. Claude confirms the transfer task has been successfully logged in the system.

Security and Access Control

Giving an LLM access to a live ERP system requires rigid boundaries. Truto provides four distinct configuration levers at the MCP token level to guarantee secure execution:

• Method Filtering (methods): Restrict the MCP server to specific HTTP verbs. Pass ["read"] to disable all create, update, and delete tools. The LLM can run inventory reports but cannot issue purchase orders.
• Tag Filtering (tags): Group tools logically. You can scope a server specifically to ["sales"] or ["inventory"] tags, ensuring an agent built for warehouse staff cannot accidentally access CRM leads.
• Secondary Authentication (require_api_token_auth): If the MCP URL is exposed, possession of the URL isn't enough. When this is set to true, the client must also supply a valid Truto API token in the Authorization header to execute tools.
• Time-to-Live (expires_at): Ideal for temporary contractors or short-lived CI/CD audits. Pass an ISO datetime, and Cloudflare KV will automatically drop the token, immediately severing the AI's access to Cin7 Core.

Moving your Cin7 Core operations to an agentic architecture allows you to stop writing brittle, point-to-point scripts for every inventory workflow. By leveraging MCP, Claude can dynamically read schemas, respect required parameters, and execute supply chain actions in real-time.