--- title: "Connect Faire to ChatGPT: Sync Inventory & Process Orders" slug: connect-faire-to-chatgpt-sync-inventory-process-orders date: 2026-09-13 author: Roopendra Talekar categories: ["AI & Agents"] excerpt: "Learn how to connect Faire to ChatGPT using Truto's auto-generated MCP server. Automate order processing, sync wholesale inventory, and manage variants." tldr: "Connect Faire to ChatGPT via Truto's managed MCP server. This guide shows how to securely expose Faire APIs as AI tools, handle order lifecycles, and automate inventory syncing without writing integration boilerplate." canonical: https://truto.one/blog/connect-faire-to-chatgpt-sync-inventory-process-orders/ --- # 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](https://truto.one/blog/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). 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](https://truto.one/blog/connect-faire-to-claude-manage-product-catalogs-shipments/) or explore our broader architectural overview on [connecting Faire to AI Agents](https://truto.one/blog/connect-faire-to-ai-agents-automate-wholesale-supply-chains/). 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. ::cta{buttonText="Talk to us" buttonUrl="/book-a-demo/"} 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](https://truto.one/blog/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/) 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](https://truto.one/blog/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/) to handle JSON-RPC translation, authentication token refreshes, and schema mapping, you can use Truto to [auto-generate an MCP server](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) 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. ```bash 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: ```json { "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. ```json { "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](https://truto.one/integrations/detail/faire). ## 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. ```mermaid 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. ```mermaid flowchart TD A["User uploads CSV
to ChatGPT"] --> B["ChatGPT reads SKUs
and stock counts"] B --> C["Call list_all_faire_products
via MCP"] C --> D["Map CSV SKUs to
Faire Variant IDs"] D --> E["Construct bulk
inventory array"] E --> F["Call faire_available_by...bulk_update
via MCP"] F --> G["Truto routes payload
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. ::cta{buttonText="Talk to us" buttonUrl="/book-a-demo/"} Ready to give your AI agents secure, authenticated access to Faire? Start building with Truto today. :::