---
title: "Connect Cin7 to Claude: Manage Sales and Production Lifecycles"
slug: connect-cin7-to-claude-manage-sales-and-production-lifecycles
date: 2026-09-16
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Cin7 to claude using Truto. Step-by-step guide to tool calling, API quirks, and autonomous workflows."
canonical: https://truto.one/blog/connect-cin7-to-claude-manage-sales-and-production-lifecycles/
---

# Connect Cin7 to Claude: Manage Sales and Production Lifecycles


If you need to connect Cin7 to Claude to automate sales order fulfillment, manage complex Bills of Materials (BOMs), or coordinate multi-branch stock transfers, 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's [REST APIs](https://truto.one/understanding-rest-apis-for-ai-agents/). You can either build and maintain this infrastructure yourself, or use a managed [integration platform like Truto](https://truto.one/how-truto-works-unified-api-for-integrations/) to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on [/connect-cin7-to-chatgpt-sync-inventory-sales-and-supply-chain/](https://truto.one/connect-cin7-to-chatgpt-sync-inventory-sales-and-supply-chain/) or explore our broader architectural overview on [/connect-cin7-to-ai-agents-automate-orders-stock-and-payouts/](https://truto.one/connect-cin7-to-ai-agents-automate-orders-stock-and-payouts/).

Giving a [Large Language Model (LLM)](https://truto.one/how-to-build-llm-agents-with-real-time-data/) read and write access to an omni-channel inventory and supply chain system like Cin7 is a serious engineering challenge. You have to map highly opaque JSON schemas to MCP tool definitions, handle bulk-array payloads, and gracefully manage strict API quotas. Every time your team needs to support a new operational workflow, 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 Cin7, connect it natively to Claude Desktop, and execute complex production and sales workflows using natural language.

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

## The Engineering Reality of the Cin7 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 Cin7's APIs is painful. Cin7 is designed for massive scale and bulk data movement across wholesale, retail, and B2B channels. Its API reflects that bulk-oriented, ERP-style design.

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

**Content-Opaque Response Models**
Cin7's API documentation frequently omits field-level breakdowns for objects like `Payment`, `ProductCategory`, or the various `BatchResultItem` objects returned by write operations. This means an LLM cannot rely on strict, predictable typing to understand the structure of the data it is about to read or write. A managed MCP server bridges this gap by automatically injecting structural hints into the tool descriptions and capturing the undocumented fields inside flexible `attributes` objects, allowing the LLM to navigate the payload without hallucinating expected keys.

**Enforced Batch Architectures**
Almost all write operations in Cin7—whether creating a branch transfer, updating stock adjustments, or generating a production job—demand a bare JSON array as the payload. Standard REST CRUD mental models (e.g., sending a single JSON object to create a single order) will fail with HTTP 400 errors. An LLM natively wants to construct single-object arguments. You must build an abstraction layer in your MCP tools that forces the LLM to format the payload as a JSON array (often referred to as `body` on the tool call) to satisfy Cin7's bulk-ingest requirements.

**Hard Limits and Silent Skips**
Cin7 enforces a hard maximum of 250 rows per page on read operations. If you ask an LLM to "list all products," you risk blowing out the context window or missing data unless you strictly enforce cursor-based pagination and explicit `where` clauses. Furthermore, bulk create endpoints (like product or contact creation) will silently skip records if identifiers like style codes already exist, returning a batch result array with hidden failure indices. Your MCP server must reliably pass these batch results back to the LLM so it can interpret which rows succeeded and which were skipped.

## Creating the Managed MCP Server for Cin7

Instead of building a translation layer from scratch, you can use Truto to automatically generate a fully compliant MCP server for Cin7. The server is derived directly from the integration's resource schema and documentation records, ensuring that only well-documented, actionable endpoints are exposed to the LLM.

You can create this MCP server in two ways: via the Truto UI, or programmatically via the API.

### Method 1: Via the Truto UI

For ad-hoc agent testing or internal workflows, generating a server via the dashboard is the fastest route:

1. Log into your Truto account and navigate to the **Integrated Accounts** page.
2. Select your connected Cin7 account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration. You can filter by methods (e.g., only `read` operations) or apply a specific expiry time.
6. Copy the generated MCP Server URL (e.g., `https://api.truto.one/mcp/abc123def456...`).

### Method 2: Via the Truto API

For platform builders provisioning AI agents programmatically for their end-users, you can generate MCP servers via a single REST call. This provisions a secure token and immediately returns a ready-to-use JSON-RPC 2.0 endpoint.

**Endpoint:** `POST /integrated-account/:id/mcp`

```bash
curl -X POST https://api.truto.one/integrated-account/YOUR_CIN7_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Cin7 Production Copilot",
    "config": {
      "methods": ["read", "write"]
    },
    "expires_at": "2025-12-31T23:59:59Z"
  }'
```

The response contains the exact URL to provide to your MCP client:

```json
{
  "id": "mcp-7a8b9c",
  "name": "Cin7 Production Copilot",
  "config": { "methods": ["read", "write"] },
  "expires_at": "2025-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/secure_token_string_here"
}
```

## Connecting Cin7 to Claude

Once you have the MCP server URL, connecting it to Claude requires no custom authentication logic or OAuth handling on the client side. The token encoded in the URL securely identifies the specific Cin7 tenant.

### Method 1: Via the Claude UI (or ChatGPT UI)

If you are using the Claude Desktop app or ChatGPT Enterprise interfaces, you can attach the MCP server directly in the settings.

**For Claude Desktop:**
1. Open Claude Desktop.
2. Go to **Settings** → **Integrations** (or **Connectors** depending on version).
3. Click **Add MCP Server**.
4. Paste your Truto MCP URL and click **Add**.
5. Claude will immediately discover the available Cin7 tools and make them available in chat.

**For ChatGPT (Developer Mode):**
1. Go to **Settings** → **Apps** → **Advanced settings**.
2. Enable **Developer mode**.
3. Under **MCP servers / Custom connectors**, add a new server.
4. Give it a name (e.g., "Cin7 ERP") and paste the Truto MCP URL.
5. Click **Save**.

### Method 2: Via Manual Configuration File (Server-Sent Events)

If you are running custom agent frameworks (like LangChain, LlamaIndex, or raw Claude API calls) or prefer configuring Claude Desktop via the config file, you can utilize the `@modelcontextprotocol/server-sse` transport.

Locate your `claude_desktop_config.json` file (typically at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows) and add the following:

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

Restart Claude Desktop. The application will execute the SSE proxy, parse the tool schemas, and expose Cin7 operations directly to the model.

## Hero Tools for Cin7

Truto exposes dozens of endpoints across Cin7's API surface, automatically mapping query parameters and array bodies into structured LLM schemas. Here are the highest-leverage tools for automating sales and production workflows.

### list_all_cin_7_products
Retrieve the master product catalog. Because of the 250-row limit and opaque attribute payloads, it is critical to instruct the LLM to use the `where` parameter to filter by specific style codes or modified dates.

> "Find the Cin7 product records updated in the last 24 hours that belong to the 'Industrial' category. Extract their style codes and barcode attributes."

### create_a_cin_7_sales_order
Generate a new sales order in Cin7. This endpoint requires the LLM to supply a JSON array of sales order objects, even if only creating a single order.

> "Create a new sales order in Cin7 for customer ID 88921. Add line items for style code 'VX-900' with a quantity of 50. Ensure the payload is a properly formatted JSON array inside the body parameter."

### list_all_cin_7_purchase_orders
Query open purchase orders to reconcile incoming stock. Useful for agents tasked with auditing supply chain delays.

> "List all open purchase orders for the supplier 'Alpha Manufacturing'. Check the expected delivery dates against today's date and identify any orders that are past due."

### get_single_cin_7_production_job_by_id
Inspect a specific manufacturing job. This is vital for syncing assembly lines with customer expectations.

> "Retrieve the details for Cin7 production job ID 9014. Tell me the current assembly status and the total quantity of output stock generated."

### list_all_cin_7_bom_masters
Query the Bill of Materials (BOM) master definitions. Essential for calculating assembly costs or verifying component requirements before creating a production job.

> "Pull the BOM master record for the finished good 'Solar Panel V2'. List the required sub-components and their relative quantities."

### cin_7_adjustments_bulk_update
Reconcile stock levels via bulk adjustments. This tool accepts an array of adjustment objects, allowing an LLM to process a discrepancy report and push updates to the ERP in one shot.

> "I have a discrepancy report showing warehouse A is short 5 units of barcode 12345, and warehouse B has 5 extra units. Execute a bulk update on the existing adjustment records to reflect these new variances."

For the complete tool inventory and JSON schema structures, visit the [Cin7 integration page](https://truto.one/integrations/detail/cin7).

## Workflows in Action

Let's look at how Claude utilizes these tools to execute multi-step business logic over the Cin7 API.

### Scenario 1: The Production Planner

A supply chain manager needs to verify component availability and initiate a manufacturing job for a custom order.

> "Check the BOM master for 'Heavy Duty Widget X'. Verify we have enough raw stock in the main branch to produce 100 units. If we do, create a production job for 100 units and return the new job ID."

**Execution Steps:**
1. Claude calls `list_all_cin_7_bom_masters` with a filter for the product name to retrieve the component list.
2. Claude loops through the components, calling `list_all_cin_7_stocks` for each to verify branch-level quantities.
3. Determining there is sufficient stock, Claude formats a bare JSON array payload and calls `create_a_cin_7_production_job`.
4. Claude reads the batch result array and reports the new Job ID back to the user.

```mermaid
sequenceDiagram
  participant User
  participant Claude as Claude Desktop
  participant MCP as Truto MCP Server
  participant Upstream as "Upstream API (Cin7)"

  User->>Claude: "Check BOM and create production job..."
  Claude->>MCP: Call list_all_cin_7_bom_masters
  MCP->>Upstream: GET /v1/BOMMasters
  Upstream-->>MCP: Array of BOMs
  MCP-->>Claude: JSON payload
  Claude->>MCP: Call list_all_cin_7_stocks (for components)
  MCP->>Upstream: GET /v1/Stock
  Upstream-->>MCP: Stock availability
  MCP-->>Claude: JSON payload
  Claude->>MCP: Call create_a_cin_7_production_job
  MCP->>Upstream: POST /v1/ProductionJobs (JSON array)
  Upstream-->>MCP: BatchResultItem array
  MCP-->>Claude: JSON payload
  Claude-->>User: "Production job #4092 created successfully."
```

### Scenario 2: The E-Commerce Escalation

A customer service rep needs to check why an order is delayed, and if it's due to a stock-out, find the incoming purchase order ETA.

> "Look up sales order #SO-992. See what items are unfulfilled, check if we have any incoming purchase orders for those items, and tell me the expected arrival date."

**Execution Steps:**
1. Claude calls `list_all_cin_7_sales_orders` with a filter for the reference number to get the order contents.
2. Claude identifies the unfulfilled style codes.
3. Claude calls `list_all_cin_7_purchase_orders` searching for open POs containing those specific style codes.
4. Claude reads the expected delivery dates from the PO payload and drafts an update for the customer.

## Handling Rate Limits in Cin7

Cin7 enforces strict [rate limits](https://truto.one/handling-api-rate-limits-and-throttling-in-ai-agents/) to protect its infrastructure from abusive scraping or runaway bulk scripts. When building AI agents, it is highly likely that parallel tool calling or deep pagination workflows will trigger these limits.

**Factual Note on Rate Limiting:** Truto does **not** automatically retry, throttle, or apply backoff on rate limit errors. When the Cin7 API returns an HTTP `429 Too Many Requests`, Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. 

The caller (your agent framework or Claude configuration) is strictly responsible for inspecting these headers, implementing exponential backoff, and retrying the tool call. Do not assume the integration layer will absorb rate limiting on your behalf.

## Security and Access Control

When exposing a critical system like Cin7 to an LLM, you must implement the [principle of least privilege](https://truto.one/security-best-practices-for-mcp-servers/). Truto MCP servers provide several security controls at creation time:

*   **Method Filtering:** Restrict the server using `config.methods`. Setting this to `["read"]` ensures the LLM can query stock and BOMs, but cannot accidentally create purchase orders or modify adjustments.
*   **Tag Filtering:** Use `config.tags` to expose only specific operational domains (e.g., exposing sales-related resources while hiding manufacturing resources).
*   **Additional Authentication:** Enable `require_api_token_auth` to force the client to send a valid Truto API token in the `Authorization` header, preventing unauthorized access if the MCP URL is leaked.
*   **Temporary Access:** Set an `expires_at` timestamp to grant an AI agent time-bound access for a specific audit or task, after which the server will automatically destroy itself.

## Automate Cin7 with Confidence

Connecting Claude to Cin7 doesn't have to involve weeks of reading dense API documentation, writing custom pagination loops, or debugging opaque JSON batch failures. By using a managed MCP server, you abstract away the REST complexities and provide the LLM with explicitly defined, auto-curated tools.

Whether you are architecting a procurement bot to manage supplier purchase orders, or a sales assistant to rapidly generate quotes and track stock transfers, Truto gives you the infrastructure to deploy AI-driven supply chain automation reliably.

> Ready to give your agents read and write access to Cin7? Connect with our engineering team to explore managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)