Connect Faire to Claude: Manage Product Catalogs & Shipments

If your team needs to connect Faire to Claude to automate wholesale orders, reconcile product catalogs, manage inventory levels, or oversee shipping logistics, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's function calls and Faire's 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 /connect-faire-to-chatgpt-sync-inventory-process-orders/ or explore our broader architectural overview on /connect-faire-to-ai-agents-automate-wholesale-supply-chains/.

Giving a Large Language Model (LLM) read and write access to a B2B wholesale marketplace like Faire is a significant engineering challenge. You have to manage strict OAuth lifecycles, map massive e-commerce JSON schemas to MCP tool definitions, and navigate Faire's specific operational constraints. Every time Faire updates an endpoint, modifies an inventory schema, or changes a fulfillment requirement, 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 Faire, connect it natively to Claude Desktop, and execute complex wholesale management workflows using natural language.

The Engineering Reality of the Faire API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable JSON-RPC 2.0 method for models to discover and execute tools, implementing the translation layer against Faire's actual APIs is historically painful. You are not just building generic CRUD operations - you are interfacing with a high-stakes supply chain system.

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

Strict Order State Machine Transitions Faire enforces a highly rigid state machine for order processing. An order moves through states like NEW, PROCESSING, PRE_TRANSIT, IN_TRANSIT, and DELIVERED. If an LLM attempts to execute a state change out of sequence - for example, trying to mark an order as shipped (create_a_faire_order_shipment) before it has been formally accepted (faire_order_processings_bulk_update) - the API will reject the request with a strict 400 error. Your MCP server must explicitly define these dependencies in the tool descriptions so the LLM understands the exact sequence of operations required to fulfill a wholesale order.

The Prepack vs. Variant Dichotomy In standard e-commerce architectures, a product has variants (e.g., sizes or colors). Faire introduces a wholesale-specific concept called "prepacks" - predefined assortments of variants sold together as a single unit (e.g., a pack containing 2 Small, 4 Medium, and 2 Large shirts). Faire uses entirely separate API routes for managing standard variants versus prepacks. If an LLM attempts to update a prepack using a standard variant endpoint, the API call will fail. Your tool schemas must clearly differentiate these entities to prevent the LLM from hallucinating incorrect payloads.

Variant ID vs. SKU Bulk Inventory Updates Faire provides two distinct ways to bulk-update inventory levels: by Faire's internal product_variant_id or by the brand's custom sku. LLMs often struggle when standardizing updates across multiple products if the internal schema is ambiguous. If your agent is reconciling data from an external ERP, it will almost certainly rely on SKUs. You must expose specific tools like faire_product_inventory_by_skus_bulk_update with highly constrained arrays to ensure the model groups SKU updates correctly instead of looping through individual API calls and exhausting your rate limits.

Generating the MCP Server for Faire

To bridge Claude and Faire, we need to spin up an MCP server. Rather than writing Node.js or Python code from scratch, Truto dynamically derives your MCP tools directly from Faire's API resource definitions and JSON schemas.

Each MCP server generated by Truto is scoped to a single integrated account (a specific Faire brand connection) and exposed via a secure URL containing a cryptographic token. You can generate this server using the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

If you are configuring this manually for internal operations:

1. Log into your Truto dashboard and navigate to the integrated account page for your connected Faire instance.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server name, allowed methods (e.g., read, write), tags (e.g., orders, inventory), and set an optional expiration date.
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For teams building programmatic AI agents, you can generate MCP servers dynamically. The Truto API validates the configuration, generates the token, and returns the ready-to-use URL.

Make a POST request to /integrated-account/:id/mcp:

curl -X POST https://api.truto.one/admin/integrated-accounts/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Faire Wholesale Fulfillment MCP",
    "config": {
      "methods": ["read", "write"],
      "tags": ["orders", "products", "inventory"]
    }
  }'

The response returns the tokenized URL:

{
  "id": "mcp_srv_9x8y7z6",
  "name": "Faire Wholesale Fulfillment MCP",
  "config": {
    "methods": ["read", "write"],
    "tags": ["orders", "products", "inventory"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}

Critical Note on Rate Limiting

When exposing Faire APIs to autonomous agents, rate limits are a major operational factor. Faire enforces strict concurrency and daily quotas. Truto does not retry, throttle, or apply backoff on rate limit errors.

When the Faire API returns an HTTP 429 rate limit error, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers per the IETF spec (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller (Claude or your orchestration layer) is entirely responsible for reading these headers, pausing execution, and implementing retry/backoff logic. Do not build agents assuming the MCP server will silently absorb or queue requests when limits are hit.

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude is a matter of configuration. The MCP server handles all OAuth token refreshes and data normalization behind the scenes.

Method A: Via the Claude UI

If you are using the Claude web interface or enterprise workspace:

1. Navigate to Settings -> Integrations.
2. Click Add MCP Server (or Custom Connector).
3. Provide a name (e.g., "Faire Wholesale Ops").
4. Paste the Truto MCP URL into the Server URL field and save.

Claude will immediately call the tools/list protocol method, dynamically fetching the exact query and body schemas for the Faire API.

Method B: Via Manual Config File (Claude Desktop)

For developers running Claude Desktop locally, you can modify your configuration file to establish an SSE (Server-Sent Events) connection to the remote MCP server.

Open your claude_desktop_config.json file (typically located in ~/Library/Application Support/Claude/ on macOS or %APPDATA%\Claude\ on Windows) and add the server:

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

Restart Claude Desktop. The application will handshake with the server and load the Faire tools into its context window.

Hero Tools for Faire

Truto dynamically generates MCP tools based on Faire's API documentation. Here are the highest-leverage tools your agent can use to manage wholesale operations.

list_all_faire_orders

Fetches a list of all Faire orders, ordered by when they were last updated. This is the primary tool for auditing order queues and identifying shipments that require processing.

"Claude, check Faire for any orders currently in the 'NEW' state that were created in the last 48 hours, and summarize the total payout values."

faire_order_processings_bulk_update

Accepts a Faire order and moves it from NEW to the PROCESSING state. This is a critical step in the Faire lifecycle - an order must be processed before any shipping data can be added.

"Claude, please accept order ID 'po_123456789' and move it into processing status so we can begin picking the inventory."

create_a_faire_order_shipment

Adds shipment tracking details to an order, transitioning its state to PRE_TRANSIT. For Upmarket Plus retailers, the API explicitly requires compliance regarding packing slips, which this tool can also validate based on its schema.

"Claude, create a shipment for order ID 'po_123456789'. The carrier is UPS and the tracking number is '1Z9999999999999999'. Mark the expected ship date for tomorrow."

list_all_faire_products

Retrieves the complete catalog of Faire products, including states, variants, prepacks, and minimum order quantities. This is essential for AI agents performing catalog audits or preparing for bulk pricing adjustments.

"Claude, list all active products in our Faire catalog and flag any items where the available quantity has dropped below our per-style minimum order quantity."

faire_product_inventory_by_skus_bulk_update

Allows the AI agent to update on-hand inventory levels across multiple variants using the brand's SKUs rather than internal Faire variant IDs. This bulk method prevents the agent from making dozens of individual API calls and hitting rate limits.

"Claude, I just received a warehouse report. Please update the Faire inventory for SKU 'TSHIRT-BLK-M' to 150 units, and SKU 'TSHIRT-WHT-L' to 75 units using a single bulk update."

create_a_faire_product_prepack

Creates a specific prepack grouping for a Faire product. Because prepacks require strict validation regarding the exact quantities of variants included in the pack, this tool provides the exact schema the LLM needs to format the payload correctly.

"Claude, create a new prepack for the 'Summer Essentials' product line. It should include 2 small, 4 medium, and 2 large variants, priced at $80 total wholesale."

To view the complete inventory of available tools, required parameters, and JSON schemas, visit the Faire integration page.

Workflows in Action

When an AI agent understands the strict schemas and lifecycle states of the Faire API, it can execute end-to-end operational workflows that would typically require a human to log into the Faire dashboard.

Scenario 1: Automated Order Processing and Fulfillment

A wholesale operations manager needs to process newly arrived orders, confirm them, and attach shipping tracking information provided by a 3PL.

"Claude, find all new orders from today. Accept them into processing, and then create shipments for them using this CSV data of FedEx tracking numbers."

Step-by-step execution:

1. Claude calls list_all_faire_orders with a query filter for state: NEW and today's date range.
2. For each returned order ID, Claude calls faire_order_processings_bulk_update to formally accept the order and shift its state to PROCESSING.
3. Claude parses the user's provided tracking data, maps the order IDs to the tracking numbers, and sequentially calls create_a_faire_order_shipment to attach the FedEx data, moving the orders to PRE_TRANSIT.

The manager receives confirmation that all wholesale orders are processed and the tracking data is successfully pushed to the retailers on Faire.

sequenceDiagram
  autonumber
  participant User
  participant Claude as Claude Desktop
  participant MCP as Truto MCP Server
  participant Faire as Faire API

  User->>Claude: "Process new orders & add tracking..."
  Claude->>MCP: tools/call (list_all_faire_orders)
  MCP->>Faire: GET /orders (state=NEW)
  Faire-->>MCP: Return Order JSON
  MCP-->>Claude: JSON-RPC Result
  
  Claude->>MCP: tools/call (faire_order_processings_bulk_update)
  MCP->>Faire: POST /orders/{id}/processing
  Faire-->>MCP: HTTP 200 OK
  MCP-->>Claude: JSON-RPC Result
  
  Claude->>MCP: tools/call (create_a_faire_order_shipment)
  MCP->>Faire: POST /orders/{id}/shipments (FedEx data)
  Faire-->>MCP: HTTP 200 OK
  MCP-->>Claude: JSON-RPC Result
  Claude-->>User: "All orders processed and shipments created."

Scenario 2: Warehouse Receiving and Bulk Inventory Reconciliation

A supply chain coordinator receives a massive shipment of goods at the warehouse and needs to push the new available stock numbers to Faire immediately to avoid stockouts on the marketplace.

"Claude, we just restocked our holiday lineup. I am pasting a list of SKUs and their new total on-hand counts. Please push this bulk update to Faire and confirm when it's done."

Step-by-step execution:

1. Claude parses the unstructured text or tabular data provided by the user into a structured JSON array of SKUs and integer quantities.
2. Claude formats the payload according to the required schema and calls faire_product_inventory_by_skus_bulk_update.
3. Claude passes the single batch payload to the MCP server, which proxies it to Faire.
4. Faire processes the bulk update and returns a confirmation array.

The coordinator bypasses the need to manually search and update individual variants in the Faire UI, resolving the inventory discrepancy in seconds using a single optimal API call.

Security and Access Control

Granting AI agents write access to a live wholesale marketplace requires strict governance. Truto's MCP architecture provides several layers of access control directly on the token configuration:

• Method Filtering: Restrict servers to specific operation types. If you only want Claude to audit stock levels without risking accidental updates, configure the server with methods: ["read"]. All create, update, and delete tools will be entirely removed from the LLM's context.
• Tag Filtering: Scope access by business domain. Using tags: ["orders"] ensures the agent can manage fulfillments but cannot access or alter product catalog definitions or brand profiles.
• Extra Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. For higher security environments, setting this flag forces the MCP client to also pass a valid Truto API token in the Authorization header, ensuring only verified internal systems can execute tools.
• Time-to-Live (expires_at): For temporary workflows - such as granting an external consultant's agent access to audit your catalog - you can set an ISO datetime for expiration. Once reached, the Durable Object alarm automatically purges the token from the database and Cloudflare KV edge storage, instantly revoking access.

Wrapping Up

Integrating Faire with Claude via MCP transforms how wholesale brands operate. By abstracting away the complex OAuth lifecycle, rate limit header normalization, and sprawling JSON schemas, engineering teams can focus on prompt engineering and workflow orchestration rather than maintaining brittle API glue code.

Whether you are automating bulk inventory reconciliation across hundreds of SKUs, strictly enforcing order state machine transitions, or programmatically generating prepacks, a managed MCP server ensures your AI agents interact with Faire securely, accurately, and reliably.

Ready to put your wholesale operations on autopilot? Generate your first managed MCP server today and watch Claude execute complex supply chain workflows natively.