Connect Faire to ChatGPT: Sync Inventory & Process Orders

If you need to connect Faire to ChatGPT to sync wholesale inventory, automate order processing, or manage complex product catalogs, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Faire's strict REST APIs. You can either spend weeks building and maintaining this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on connecting Faire to Claude or explore our broader architectural overview on connecting Faire to AI Agents.

Giving a Large Language Model (LLM) read and write access to a wholesale marketplace platform like Faire is a significant engineering challenge. You must navigate strict order state machines, handle bulk update endpoints for inventory levels, and manage polymorphic product variants. Every time Faire updates its API schema, your custom server code must be updated, redeployed, and tested.

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

Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds. :::

The Engineering Reality of the Faire 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, implementing it against Faire's highly specific supply chain API introduces several major architectural hurdles.

If you decide to build a custom MCP server for Faire, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Faire:

The Strict Order State Machine

Unlike generic eCommerce APIs that allow you to patch an order status to almost any value, Faire enforces a strict state machine. Orders begin in a NEW state and must be explicitly acknowledged and moved to PROCESSING before you can manipulate fulfillment data or generate packing slips. If your AI agent attempts to create a shipment for an order that hasn't been acknowledged, the Faire API will reject the payload. Your MCP server must either encode these state transitions into the tool definitions or expose explicit state-transition tools (like faire_order_processings_bulk_update) and instruct the LLM on the exact sequence of operations.

Disjointed Inventory and Catalog Endpoints

In many APIs, updating a product's inventory is as simple as patching the product record. Faire separates catalog management from inventory management. To update the available stock, you cannot hit the product endpoint; you must use dedicated bulk inventory endpoints (e.g., faire_available_by_product_variant_ids_bulk_update). This means an LLM tasked with "update the price and stock of the blue mug" must actually call two entirely different tools, managing the variant ID state across both requests.

Variant Immutability

Faire's data model heavily restricts how variants are modified. You cannot update the option sets (like changing a size from "Small" to "Medium") of an existing variant. To change options, the API requires you to delete the existing variant and create a completely new one. An AI agent needs highly accurate JSON Schema descriptions to understand this limitation, otherwise, it will constantly hallucinate invalid PATCH payloads that the Faire API will reject.

How to Generate a Faire MCP Server with Truto

Instead of building a Node.js or Python server from scratch to handle JSON-RPC translation, authentication token refreshes, and schema mapping, you can use Truto to auto-generate an MCP server scoped specifically to an authenticated Faire account.

Truto creates these tools dynamically. It reads the underlying Faire API documentation and resources, converting them into MCP-compatible tools/list and tools/call JSON-RPC responses.

You can generate the MCP server in two ways: via the Truto UI or via the API.

Method 1: Via the Truto UI

For ad-hoc agent testing or internal IT operations, you can generate an MCP URL directly from your dashboard:

1. Navigate to the Integrated Accounts page in your Truto dashboard and select the connected Faire account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., filter by methods like "read" and "write", or tags like "orders" and "inventory").
5. Copy the generated MCP server URL. Treat this URL like a secret—it contains the cryptographic hash that authenticates requests to this specific Faire tenant.

Method 2: Via the Truto API

For production workflows where your application deploys AI agents programmatically on behalf of your users, you should generate the MCP server via the Truto REST API.

Make a POST request to /integrated-account/:id/mcp, passing in filters to strictly scope what the LLM can access.

curl -X POST https://api.truto.one/integrated-account/$FAIRE_INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Faire Order Processing Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["orders", "inventory", "products"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API responds with a secure endpoint:

{
  "id": "mcp_abc123",
  "name": "Faire Order Processing Agent",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8..."
}

This single url handles all JSON-RPC routing, parameter validation, schema flat-mapping, and underlying OAuth authentication.

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you need to register it as a custom connector in ChatGPT. You can do this through the UI for user-facing agents or via configuration files for local or headless setups.

Method A: Via the ChatGPT UI

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education, you can add the MCP server directly to the interface.

1. In ChatGPT, navigate to Settings → Apps → Advanced settings.
2. Enable Developer mode (MCP capabilities are currently gated behind this flag).
3. Under MCP servers / Custom connectors, click Add new server.
4. Name the connection (e.g., "Faire Supply Chain API").
5. Paste the Truto MCP url you generated earlier.
6. Click Save.

ChatGPT will immediately perform the MCP initialize handshake, discover the Faire tools, and populate them in your agent's context.

Method B: Via Manual Configuration File (SSE)

If you are running a local agentic framework or a custom client that supports MCP via Server-Sent Events (SSE), you can configure the connection using a standard JSON file. Since Truto hosts the server remotely, you map the client to an SSE proxy.

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

This command tells the MCP client to use the official SSE transport adapter to connect to the remote Truto endpoint.

Faire Hero Tools for AI Agents

When Truto derives tools from the Faire API documentation, it injects highly specific JSON schemas into the tool descriptions. This guides the LLM to format requests correctly. Here are 6 high-leverage hero tools your AI agent can use to manage a wholesale business.

1. list_all_faire_orders

Retrieves a list of wholesale orders, ordered by their updated_at timestamp. This tool supports complex query parameters for filtering by order state (e.g., NEW, PROCESSING, SHIPPED). Truto automatically handles the pagination cursors, explicitly instructing the LLM to pass the next_cursor back unchanged during sequential fetches.

"Fetch all unfulfilled Faire orders that were placed this week. Filter for orders currently in the 'NEW' state so we can review them for processing."

2. faire_order_processings_bulk_update

This is a critical custom method tool for the Faire state machine. It accepts a Faire order and moves it from the NEW state into the PROCESSING state. This signifies to the retailer that the brand has acknowledged the wholesale request and is preparing the items.

"Accept order ID po_123456789 and move it into processing status immediately."

3. get_single_faire_order_packing_slip_pdf_by_id

A specialized operational tool that allows the LLM to retrieve the binary PDF data for a packing slip. For Upmarket Plus retailers on Faire, including this printed slip in the box is a strict requirement.

"Download the PDF packing slip for order po_987654321 so I can attach it to our warehouse dispatch email."

4. faire_available_by_product_variant_ids_bulk_update

Because Faire separates inventory logic from the core catalog API, this tool is required for stock synchronization. It allows the agent to update available inventory levels for specific product variants in a single batch request, bypassing the need to iterate through individual items.

"We just received a new shipment of raw materials. Update the available inventory for variant ID pv_abc123 to 150 units, and variant ID pv_xyz789 to 75 units."

5. update_a_faire_product_by_id

Used to manage high-level product metadata such as the product name, description, unit multipliers, and lifecycle state. Crucially, while this tool can modify product-level data, the LLM is instructed by the underlying JSON Schema that variants require separate operations.

"Update the description of product p_55555 to mention that the materials are now 100% recycled, and ensure the minimum order quantity is set to 10."

6. create_a_faire_product_variant

Because existing variants in Faire cannot have their underlying option sets updated, agents must use this tool to introduce new configurations (like a new color or size) to an existing product parent.

"Add a new 'Extra Large' variant to the organic cotton t-shirt product (ID p_44444). Set the wholesale price to $12.50 and the retail price to $25.00."

For the complete tool inventory, detailed JSON schemas, and all supported custom methods, see the Faire integration page.

Workflows in Action

AI agents excel when orchestrating multi-step workflows. By providing ChatGPT with the Faire MCP server, you can automate complex supply chain tasks that typically require a human to log into the Faire portal.

Workflow 1: New Order Triage and Processing

When a wholesale buyer places a large order, the brand must verify the stock, acknowledge the order, and retrieve the packing slip for the warehouse floor.

"Check our Faire account for any 'NEW' orders. If you find any, accept them to move them into processing, and then generate a download link for their packing slips."

1. list_all_faire_orders: The agent queries Faire for orders where state equals NEW.
2. faire_order_processings_bulk_update: For each order ID returned, the agent executes the state transition custom method to officially accept the order.
3. get_single_faire_order_packing_slip_pdf_by_id: The agent fetches the PDF binary for each accepted order.

ChatGPT processes the binary returns and provides the user with a clean summary table of accepted orders alongside the downloadable PDF files, completing a task in 10 seconds that usually takes minutes of clicking through the Faire UI.

sequenceDiagram
    autonumber
    participant User as User Prompt
    participant ChatGPT as "ChatGPT Pro"
    participant Truto as "Truto MCP Server"
    participant Faire as "Faire API"

    User->>ChatGPT: "Find NEW orders, process them, get slips"
    ChatGPT->>Truto: Call list_all_faire_orders (state=NEW)
    Truto->>Faire: GET /v2/orders?state=NEW
    Faire-->>Truto: Return Order [po_123]
    Truto-->>ChatGPT: JSON RPC Result
    ChatGPT->>Truto: Call faire_order_processings_bulk_update (po_123)
    Truto->>Faire: POST /v2/orders/po_123/processing
    Faire-->>Truto: 200 OK (State: PROCESSING)
    Truto-->>ChatGPT: JSON RPC Result
    ChatGPT->>Truto: Call get_single_faire_order_packing_slip_pdf_by_id (po_123)
    Truto->>Faire: GET /v2/orders/po_123/packing-slip
    Faire-->>Truto: PDF Binary
    Truto-->>ChatGPT: JSON RPC Result
    ChatGPT-->>User: Orders processed. Here are the packing slips.

Workflow 2: End-of-Day Inventory Reconciliation

Wholesale inventory fluctuates rapidly. If your warehouse software updates a central spreadsheet, you can ask ChatGPT to synchronize those new stock levels with the Faire marketplace.

"Here is a CSV of our latest warehouse stock counts. Please cross-reference this with our active Faire products and update the available inventory levels for any variants that have changed."

1. Data Extraction: ChatGPT reads the provided CSV file to map SKUs to the new stock counts.
2. list_all_faire_products: The agent retrieves the active catalog to map the CSV's SKUs to Faire's internal product_variant_id strings.
3. faire_available_by_product_variant_ids_bulk_update: The agent constructs a single, bulk JSON payload containing the updated inventory levels and fires the batch update tool.

This workflow demonstrates the power of the flat input namespace in Truto's JSON-RPC router. The agent passes a single complex object containing both the path parameters and the bulk array body, which Truto safely reconstructs and proxies to Faire.

flowchart TD
    A["User uploads CSV<br>to ChatGPT"] --> B["ChatGPT reads SKUs<br>and stock counts"]
    B --> C["Call list_all_faire_products<br>via MCP"]
    C --> D["Map CSV SKUs to<br>Faire Variant IDs"]
    D --> E["Construct bulk<br>inventory array"]
    E --> F["Call faire_available_by...bulk_update<br>via MCP"]
    F --> G["Truto routes payload<br>to Faire API"]
    G --> H["Inventory synchronized"]

Security and Access Control

Giving an LLM access to wholesale financial data and live inventory requires strict boundaries. Truto's MCP servers are designed with zero-trust principles at the routing layer:

• Method Filtering: When generating the MCP URL, you can restrict the server to specific operations via config.methods. Passing ["read"] ensures the agent can list orders and products but cannot accidentally cancel an order or update a price.
• Tag Filtering: Limit the server to specific domains using config.tags. A server tagged with ["orders"] will completely hide all catalog and inventory tools from the LLM, preventing hallucinated cross-domain actions.
• Secondary Authentication: By default, the MCP URL acts as a bearer token. For high-security environments, setting require_api_token_auth: true forces the MCP client to also pass a valid Truto API token in the headers, adding a secondary layer of identity verification.
• Ephemeral Access (TTL): You can pass an expires_at ISO datetime when creating the server. Once the timestamp is reached, a distributed cleanup alarm triggers, immediately revoking the token and purging it from the key-value store.
• Hard Cascades: MCP servers are strictly scoped to a single connected tenant. If the underlying Faire OAuth integration is deleted or revoked, the database cascade automatically destroys all associated MCP servers instantly.

Handling Faire Rate Limits in Production

Faire enforces aggressive rate limits to protect its marketplace infrastructure. A critical reality of building AI agents is that LLMs often operate in tight, recursive loops (like paginating through thousands of orders), which can easily trigger 429 Too Many Requests errors.

It is a vital architectural fact that Truto does not retry, throttle, or apply backoff on rate limit errors.

When the upstream Faire API returns an HTTP 429, Truto immediately passes that exact error back to the MCP client (your AI agent). However, to make this actionable for the LLM, Truto intercepts and normalizes the raw upstream rate limit information into standardized IETF headers:

• ratelimit-limit
• ratelimit-remaining
• ratelimit-reset

The caller (your agentic framework or ChatGPT itself) is strictly responsible for reading these standardized headers and implementing its own retry or backoff logic. Do not expect the MCP server to absorb or queue requests automatically. Instruct your agents in their system prompt to observe rate limit errors and wait for the ratelimit-reset window before retrying a failed tool call.

Stop Writing Integration Boilerplate

Connecting Faire to ChatGPT via a custom MCP server means taking ownership of JSON schema definitions, OAuth lifecycles, and Faire's unique wholesale state machines. Every time a new method is added, your engineering team has to update the routing layer.

By using Truto's dynamically generated MCP servers, you shift that burden entirely. Tools are derived directly from real-time documentation, authentication is handled transparently, and the complex business of proxying JSON-RPC to REST is fully abstracted.

Ready to give your AI agents secure, authenticated access to Faire? Start building with Truto today. :::