---
title: "Connect Cin7 Core to Claude: Sync Inventory & Logistics via MCP"
slug: connect-cin7-core-to-claude-sync-inventory-purchases-and-logistics
date: 2026-10-19
author: Riya Sethi
categories: ["AI & Agents"]
excerpt: "Learn how to connect Cin7 Core to Claude using a managed MCP server. Automate inventory syncs, advanced purchases, and warehouse logistics with AI agents."
tldr: "Connect Cin7 Core to Claude using Truto's managed MCP server. This guide covers bypassing Cin7's API quirks, configuring secure tool access, and executing multi-step inventory workflows."
canonical: https://truto.one/blog/connect-cin7-core-to-claude-sync-inventory-purchases-and-logistics/
---

# 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](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 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](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). If your team uses ChatGPT, check out our guide on [connecting Cin7 Core to ChatGPT](https://truto.one/connect-cin7-core-to-chatgpt-automate-orders-stocks-and-invoices/) or explore our broader architectural overview on [connecting Cin7 Core to AI Agents](https://truto.one/connect-cin7-core-to-ai-agents-orchestrate-sales-and-crm-workflows/).

Giving a Large Language Model (LLM) read and write access to a [complex ERP and inventory management system](https://truto.one/connect-cin7-to-chatgpt-sync-inventory-sales-and-supply-chain/) 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](https://truto.one/connect-cin7-to-ai-agents-automate-orders-stock-and-payouts/) using natural language.

> Want to give your AI agents secure, authenticated access to Cin7 Core and 100+ other B2B APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)

## 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.

```bash
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:

```json
{
  "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](https://truto.one/integrations/detail/cin7core)).*

### `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](https://truto.one/connect-cin7-to-claude-manage-sales-and-production-lifecycles/). 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.

```mermaid
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.