Connect Fulfil to Claude: Sync Logistics, Contacts, and Reports

If you need to connect Fulfil to Claude to automate e-commerce operations, manage logistics, process purchase orders, or synchronize inventory, you need a Model Context Protocol (MCP) server. This server acts as the critical translation layer between Claude's JSON-RPC tool calls and Fulfil's specialized REST architecture. You can either build and maintain this infrastructure from scratch, 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 /connect-fulfil-to-chatgpt-manage-orders-products-and-shipments/ or explore our broader architectural overview on /connect-fulfil-to-ai-agents-automate-sales-and-inventory-workflows/.

Giving a Large Language Model (LLM) read and write access to a sprawling ERP and inventory management ecosystem like Fulfil is an immediate engineering bottleneck. You must manage complex token lifecycles, parse deeply nested model architectures into flat MCP tool definitions, and handle Fulfil's specific constraints around object serialization and workflow execution.

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

The Engineering Reality of the Fulfil API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against an ERP like Fulfil exposes you to highly specific architectural quirks. Fulfil operates as an object-relational mapping exposed over REST. It does not behave like a standard CRUD API.

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

The Serialization Summary Trap In a standard REST API, making a GET request to a resource ID (e.g., /sales_order/<id>) returns the complete object. In Fulfil, fetching a record by ID only returns what Fulfil calls a "serialize" - a lightweight summary of the record containing basic metadata. To get specific, granular fields, an LLM cannot just use the standard GET endpoint. It must use the list method combined with a specific where filter (e.g., {"id": <id>}) and a fields array. Building an MCP server requires writing an abstraction layer that intercepts an LLM's request for a single record and rewrites it as a complex filtered list query.

State Management via Workflow Execution LLMs are trained on typical CRUD patterns. If an LLM wants to mark a sales order as confirmed, it will naturally try to construct a PATCH payload setting {"state": "confirmed"}. Fulfil rejects this entirely. You can never change a record's state by writing to the state field. Instead, state transitions require calling specific model workflow methods (like confirm or process) against the record ID. Your MCP server must expose these discrete workflow executions as separate tools (e.g., fulfil_sales_orders_execute) and explicitly instruct the LLM on how to use them, or the model will endlessly hallucinate invalid PATCH requests.

Array-Enforced Payloads Fulfil enforces bulk-ready data structures even for single operations. When creating a contact or a shipment, the payload must be sent as params.vlist, which requires an array structure even if you are only creating one record. Without heavily tuned JSON Schemas guiding the LLM, Claude will consistently send standard JSON objects instead of the required array-wrapped payloads, resulting in immediate 400 Bad Request errors.

Generating the Fulfil MCP Server

Instead of building an MCP proxy server from scratch, handling Fulfil's serialization rules, and writing custom mapping logic, you can use Truto to generate a production-ready MCP server instantly. Truto abstracts Fulfil's complex model schemas into clean, dynamically generated tools.

Truto scopes every MCP server to a single integrated account. The server URL contains a cryptographically hashed token that authenticates the specific tenant connection, meaning the URL alone is enough to authenticate and serve tools to Claude without extra client-side configuration.

You can generate this server in two ways.

Method 1: Via the Truto UI

For administrators and operators, the UI provides a quick way to generate a server URL with granular access controls.

1. Navigate to the Integrated Accounts page in your Truto dashboard and select the connected Fulfil account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure your server settings. You can restrict the server to specific tags (e.g., sales, logistics) or specific operations (e.g., read only).
5. Click Save and copy the generated MCP Server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For developers building programmatic onboarding flows or multi-tenant AI agents, you can generate MCP servers dynamically via the Truto REST API.

Make a POST request to /integrated-account/:id/mcp with your desired configuration:

curl -X POST https://api.truto.one/api/integrated-account/<fulfil_account_id>/mcp \
  -H "Authorization: Bearer <YOUR_TRUTO_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude Desktop - Fulfil Logistics",
    "config": {
      "methods": ["read", "write", "custom"]
    },
    "expires_at": null
  }'

The API returns a secure, ready-to-use endpoint:

{
  "id": "mcp_srv_9x8y7z6",
  "name": "Claude Desktop - Fulfil Logistics",
  "config": { 
    "methods": ["read", "write", "custom"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}

Handling Fulfil Rate Limits via Truto

When exposing Fulfil to an LLM, it is easy for an autonomous agent to trigger rate limits by executing loops or rapidly paginating through large catalogs.

Factual note on rate limits: Truto does not automatically retry, throttle, or apply backoff logic on rate limit errors. When the upstream Fulfil API returns an HTTP 429, Truto passes that exact error directly to the caller (your MCP client or Claude). Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller is strictly responsible for interpreting these headers and implementing their own retry or backoff logic. Do not expect the MCP server to absorb or queue requests when Fulfil's limits are saturated.

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude is a straightforward configuration step. All JSON-RPC 2.0 communication happens over standard HTTP POST requests.

Method A: Via the Claude UI (Web/Desktop)

If you are using Claude Desktop or Claude Web on an eligible plan (Team/Enterprise/Pro), you can add the server directly via the interface.

1. In Claude, navigate to Settings -> Integrations (or Connectors depending on your plan tier).
2. Click Add MCP Server or Add custom connector.
3. Give the connection a descriptive name (e.g., "Fulfil ERP").
4. Paste the Truto MCP URL (https://api.truto.one/mcp/...) into the Server URL field.
5. Click Add.

Claude will immediately ping the endpoint, execute an initialize handshake, and call tools/list to discover all available Fulfil operations.

Method B: Via the Manual Configuration File

For developers managing Claude Desktop locally, you can modify the configuration JSON file directly. This relies on the open-source @modelcontextprotocol/server-sse package to bridge the connection to Truto's remote endpoint.

Locate your Claude config file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Update the configuration to include the Truto MCP server:

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

Restart Claude Desktop. The application will read the configuration, boot the SSE proxy, and register the Fulfil tools.

sequenceDiagram
    participant Claude as Claude Desktop
    participant SSE as MCP SSE Proxy
    participant Truto MCP as Truto MCP Server
    participant Fulfil as Fulfil API

    Claude->>SSE: Boot & read config.json
    SSE->>Truto MCP: POST /mcp/... (initialize)
    Truto MCP-->>SSE: Server capabilities & metadata
    SSE->>Truto MCP: POST /mcp/... (tools/list)
    Truto MCP-->>SSE: JSON schemas for Fulfil tools
    SSE-->>Claude: Register native tools
    
    Note over Claude,Fulfil: Agent is ready to execute commands

Hero Tools for Fulfil

Truto automatically derives tool definitions from Fulfil's model documentation, injecting descriptions and JSON schemas that guide the LLM to format requests correctly.

Here are 6 high-leverage hero tools exposed by the Truto Fulfil MCP Server.

1. list_all_fulfil_sales_orders

Retrieves sales orders using Fulfil's find method. This tool is critical because it allows the LLM to pass specific where arrays to filter data, rather than pulling the entire database. Truto handles the cursor-based pagination through every page.

Usage Note: The LLM must construct the where parameter carefully based on Fulfil's syntax (e.g., [["party.name", "ilike", "%Acme%"]]).

"Find all sales orders placed by Acme Corp in the last 30 days and summarize their total amounts and current status."

2. update_a_fulfil_sales_order_by_id

Updates specific data fields on a sales order.

Usage Note: The schema explicitly instructs the LLM: never attempt to change the state field using this tool. This tool is exclusively for updating data values (like shipping addresses or internal notes). State changes must use the execute tool.

"Update sales order 10452. Change the internal reference note to 'Priority Shipping Requested' and update the customer PO number to PO-998."

3. fulfil_sales_orders_execute

Calls a workflow or model method on one or more sales orders. This is the only valid way to change the state of an object in Fulfil.

Usage Note: The LLM must provide the specific workflow method name (such as confirm or process) and an array of record IDs in params.ids.

"Take sales orders 10452 and 10453 and execute the 'confirm' workflow on them so they move out of the draft state."

4. list_all_fulfil_customer_shipments

Queries logistics and outbound delivery records. This is vital for cross-referencing sales orders with their actual physical fulfillment status and tracking numbers.

Usage Note: Often chained after finding a sales order to retrieve the related shipment entities.

"Check the fulfillment status for sales order 10452. Find the associated customer shipments and give me the tracking numbers and courier information."

5. create_a_fulfil_contact

Creates a new contact (customer, supplier, or other party) in the Fulfil CRM module.

Usage Note: The LLM is guided by the schema to send the records inside a params.vlist array, satisfying Fulfil's requirement for bulk-formatted payloads even for single record creation.

"Create a new customer contact for Jane Doe at Stark Industries. Her email is jane@stark.com and tag her as a B2B wholesale buyer."

6. get_single_fulfil_model_schema_by_id

Retrieves the architectural schema for any Fulfil model. This is an introspective tool that allows Claude to discover what fields, types, allowed values, and workflow methods exist for a given model (e.g., sales_order or product).

Usage Note: This acts as a self-healing mechanism. If Claude doesn't know the exact field name to query, it can call this tool first to read the documentation.

"I need to update a purchase order, but I don't know the allowed status transitions. Pull the model schema for 'purchase_order' and list the available workflow methods."

To view the complete inventory of available tools, including bulk updates, purchase orders, products, and reporting schemas, visit the Fulfil integration page.

Workflows in Action

With the MCP server connected to Claude, you can orchestrate complex, multi-step supply chain operations. The LLM acts as the reasoning engine, breaking down natural language requests into a sequence of specific Fulfil API calls.

Scenario 1: Order Investigation and Logistics Tracking

A support agent needs to track down a delayed order for a specific client without leaving their chat interface or opening the ERP dashboard.

"A customer from 'Globex Corporation' is asking about their recent order. Find their latest sales order, check if it has been shipped, and give me the tracking details."

Tool Execution Sequence:

1. list_all_fulfil_contacts - Claude queries the contact model with a where filter [["name", "ilike", "%Globex%"]] to retrieve the party ID.
2. list_all_fulfil_sales_orders - Claude queries sales orders using a where filter matching the party ID and sorting by creation date descending, extracting the specific order ID.
3. list_all_fulfil_customer_shipments - Claude queries shipments where the sales_order matches the retrieved order ID.

Result: Claude synthesizes the data and responds: "I found the latest order for Globex Corporation (Order #8832). It was processed yesterday. The associated customer shipment has been dispatched via FedEx, tracking number 773499201. The package is currently in transit."

Scenario 2: Batch Processing and State Transitions

A warehouse manager needs to automate the end-of-day workflow for confirming checked orders.

"Find all sales orders in the 'draft' state that were created today. Review them, and execute the confirm workflow on all of them to send them to fulfillment."

Tool Execution Sequence:

1. list_all_fulfil_sales_orders - Claude passes a where filter for [["state", "=", "draft"], ["create_date", ">=", "<today's date>"]].
2. fulfil_sales_orders_execute - Claude extracts the array of IDs from the previous step and calls this tool, passing method="confirm" and the array to params.ids.

Result: Claude processes the batch operation, successfully transitioning the orders through Fulfil's internal logic state machine, and replies: "I found 14 draft sales orders created today. I have successfully executed the 'confirm' workflow on all of them. They are now queued for fulfillment."

flowchart TD
    User["User Prompt:<br>Confirm today's draft orders"]
    Claude["Claude Desktop (Agent)"]
    Tool1["Tool: list_all_fulfil_sales_orders<br>where: state=draft"]
    Tool2["Tool: fulfil_sales_orders_execute<br>method: confirm, ids: [..]"]
    Fulfil[("Fulfil ERP")]

    User --> Claude
    Claude -->|"1. Search drafts"| Tool1
    Tool1 --> Fulfil
    Fulfil -->|"Returns 14 IDs"| Tool1
    Tool1 --> Claude
    Claude -->|"2. Execute workflow"| Tool2
    Tool2 --> Fulfil
    Fulfil -->|"State updated"| Tool2
    Tool2 --> Claude
    Claude -->|"Confirmation Message"| User

Security and Access Control

Exposing an ERP system to an autonomous agent requires strict security boundaries. The Truto MCP server provides multiple configuration layers to ensure Claude only accesses what you explicitly allow.

• Method Filtering (config.methods): Restrict the MCP server to specific operation types. Setting methods: ["read"] ensures the server will only generate tools for get and list operations, physically preventing the LLM from executing state changes or creating records.
• Tag Filtering (config.tags): Scope the server to specific functional areas based on integration tags. You can limit the server to only expose tools related to logistics or contacts, hiding sensitive financial or reporting endpoints entirely.
• Additional Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. Enabling this flag requires the caller to pass a valid Truto API token in the Authorization header, adding a second layer of identity verification.
• Automatic Expiration (expires_at): Generate short-lived MCP servers for temporary access. Once the ISO datetime is reached, the server is automatically dismantled, its configurations deleted, and all tool execution ceases instantly.

Moving Forward with Agentic Workflows

Connecting Fulfil to Claude via a managed MCP server transforms a rigid, highly complex ERP into an accessible, conversational interface. By abstracting away Fulfil's specific constraints—like serialization summaries, array-enforced payloads, and discrete workflow state executions—Truto allows your AI agents to interact with supply chain data intuitively and securely. You maintain total control over access boundaries and rate limit handling, while empowering teams to orchestrate logistics and sales pipelines entirely through natural language.