Connect Ecwid to ChatGPT: Manage Orders, Products, and Inventory

If you want to connect Ecwid to ChatGPT to automate store operations, you need a Model Context Protocol (MCP) server. This infrastructure acts as the translation layer between the Large Language Model's (LLM) natural language tool calls and the Ecwid REST API. If your team uses Claude, check out our guide on connecting Ecwid to Claude or explore our broader architectural overview on connecting Ecwid to AI Agents.

Giving an AI agent read and write access to an active e-commerce database is an engineering challenge. You must handle complex product variation logic, nested JSON structures for order histories, and strict API limits. You can either spend engineering cycles building, hosting, and maintaining a custom MCP server for Ecwid, or you can use a managed platform like Truto to dynamically generate a secure, authenticated MCP server URL instantly.

This guide breaks down exactly how to use Truto to generate a secure MCP server for Ecwid, connect it natively to ChatGPT, and execute complex store management workflows using natural language.

The Engineering Reality of the Ecwid API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover and invoke tools, the reality of implementing it against Ecwid's specific API is painful. If you decide to build a custom MCP server, your engineering team assumes ownership of the entire API lifecycle.

Here are the specific integration challenges that break standard CRUD assumptions when working with Ecwid:

Product Variations vs. Base Products

Ecwid separates base product inventory from variation inventory (combinations of options like Size and Color). If an LLM attempts to adjust the stock of a specific t-shirt size, it cannot just call a generic update on the base product ID. It must know to use the ecwid_product_variation_adjust_stock endpoint, providing both the product_id and the combination_id. If your MCP server does not expose these distinctly with highly descriptive schemas, the LLM will hallucinate base product updates, breaking your inventory counts.

Abandoned Cart Conversion Logic

In Ecwid, abandoned carts exist as separate entities from standard orders. If a user asks the AI agent to "convert cart 12345 into an order", the agent cannot patch an order status. It must execute a specific RPC-style call to the cart conversion endpoint. Your server must map this business logic clearly so the LLM understands the state machine of an e-commerce checkout flow.

Rate Limits and 429 Errors

Ecwid enforces API rate limits based on the store's pricing plan. If your AI agent tries to fetch 10,000 orders to calculate metrics without pagination, it will hit the limit. It is critical to understand that Truto does not retry, throttle, or apply exponential backoff on rate limit errors. When the upstream Ecwid API returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. The AI agent or client application is strictly responsible for implementing its own retry and backoff logic based on these headers.

How to Create the Ecwid MCP Server

Truto dynamically generates MCP tools based on the existing integration documentation and resource definitions. You can spin up an MCP server for a connected Ecwid store using either the Truto UI or the API.

Method 1: Via the Truto UI

1. Log into your Truto dashboard and navigate to the Integrated Accounts page.
2. Select your connected Ecwid account.
3. Click on the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., allow all methods, or restrict to read-only).
6. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the Truto API

For teams embedding this setup into their own internal admin tools, you can create the server programmatically. The API validates that the integration has tools available, generates a secure token, and returns a ready-to-use URL.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Ecwid Store Ops MCP",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'

The response contains the exact URL your LLM client needs:

{
  "id": "ecwid-mcp-8899",
  "name": "Ecwid Store Ops MCP",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/abcd1234efgh5678"
}

How to Connect the MCP Server to ChatGPT

Once you have your Truto MCP URL, you can connect it to ChatGPT so the model can read and write your Ecwid data.

Method 1: Via the ChatGPT UI

If you have a ChatGPT Pro, Plus, Enterprise, or Education account, you can add custom connectors directly in the web interface:

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to ON.
3. Under the MCP servers or Custom connectors section, click Add new server.
4. Give the connector a name (e.g., "Ecwid Store (Truto)").
5. Paste the Truto MCP URL you generated earlier into the Server URL field.
6. Save the configuration. ChatGPT will immediately connect, perform an initialization handshake, and list the available Ecwid tools.

Method 2: Via Manual Configuration File

If you are running a local MCP client or using the Claude Desktop app as a unified agent interface for your team, you can connect using a JSON configuration file pointing to an SSE transport layer. Add the following to your mcp-servers.json config:

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

Restart your client, and the agent will detect the tools dynamically.

Hero Tools for Ecwid

Truto automatically generates a massive suite of tools for Ecwid by parsing the integration's schemas. Here are the highest-leverage operations for AI-driven e-commerce management.

list_all_ecwid_order

This tool fetches an array of orders for a store. It supports parameters for filtering by date, payment status, or fulfillment status, allowing the agent to audit order pipelines efficiently.

"Fetch all unfulfilled orders from the past 24 hours and format a summary table for me."

create_a_ecwid_product

This tool allows the LLM to insert a new product into the catalog. It accepts the sku, name, price, quantity, and optional catalog settings directly in the request body.

"Create a new product in the store called 'Summer V-Neck Tee', assign it a price of 24.99, and set the initial stock to 150."

create_a_ecwid_order_tax_invoice

Generating invoices manually for B2B customers is tedious. This tool commands the Ecwid backend to generate the official tax invoice for an existing order ID, allowing the agent to handle customer billing requests instantly.

"The customer for order #99402 requested a formal invoice. Generate the tax invoice for that order ID now."

update_a_ecwid_product_variation_by_id

For complex catalogs, this tool updates specific SKU variations. The LLM can modify the price, stock, weight, or attributes of a specific combination (like Large / Blue) without affecting the base product.

"We just received a shipment. Increase the stock of combination ID 88374 under product ID 10992 by 45 units."

list_all_ecwid_abandoned_cart

Abandoned carts are distinct records from orders. This tool fetches carts that users left behind, exposing the subtotal, email, items, and recovery URLs so the agent can analyze lost revenue.

"List the top 5 abandoned carts from this week with a subtotal over $100 and give me their recovery URLs."

create_a_ecwid_abandoned_cart_order

This powerful RPC-style tool allows an AI agent to forcefully convert an abandoned cart into an active order. This is typically used when a support rep finalizes a stalled transaction with a customer over chat.

"The customer for abandoned cart ID #abc-99 approved the charge via chat. Convert their cart into an active order now."

For the complete inventory of tools, schemas, and required parameters, review the Ecwid integration page.

Workflows in Action

AI agents excel at orchestrating multi-step API operations that would normally require a human to click through multiple screens in the Ecwid dashboard. Here are two real-world examples of how ChatGPT utilizes these tools.

Scenario 1: Recovering High-Value Abandoned Carts

A store manager wants to manually review and process stalled B2B carts.

"Find the highest value abandoned cart from yesterday. If the total is over $500, convert it into an order and generate the tax invoice for our records."

Tool Execution Sequence:

1. list_all_ecwid_abandoned_cart: The agent requests carts filtered by yesterday's date, parsing the total fields to identify the highest value record.
2. create_a_ecwid_abandoned_cart_order: The agent passes the store_id and the extracted cart_id to convert the record into a live order.
3. create_a_ecwid_order_tax_invoice: Using the new orderNumber returned from step 2, the agent generates the invoice.

flowchart TD
    User["User Prompt"] --> A
    A["list_all_ecwid_abandoned_cart<br>(Fetch high-value carts)"] --> B
    B["create_a_ecwid_abandoned_cart_order<br>(Convert cart to order)"] --> C
    C["create_a_ecwid_order_tax_invoice<br>(Generate final invoice)"]
    C --> Result["Agent returns summary<br>and invoice status to user"]

The agent returns a natural language summary confirming the conversion and the successful generation of the invoice.

Scenario 2: Managing Variation Inventory During a Rush

A warehouse operator needs to update inventory fast based on a physical stock count, dealing specifically with variations.

"I just counted the Medium Red hoodies (Product ID: 501). The system is wrong - adjust the stock for variation ID 22 to exactly 14 units."

Tool Execution Sequence:

1. get_single_ecwid_product_variation_by_id: The agent looks up the variation to determine current stock levels.
2. ecwid_product_variation_adjust_stock: The agent calculates the delta between current stock and the requested 14 units, passing the quantityDelta to correctly adjust the inventory without hard-overwriting concurrent purchases.

sequenceDiagram
    participant Agent as ChatGPT Agent
    participant Ecwid as Ecwid API

    Agent->>Ecwid: get_single_ecwid_product_variation_by_id(product 501, variation 22)
    Ecwid-->>Agent: Returns current stock (e.g., 20)
    Agent->>Agent: Calculates delta (-6)
    Agent->>Ecwid: ecwid_product_variation_adjust_stock(delta: -6)
    Ecwid-->>Agent: Returns updateCount (1)
    Agent->>User: "Stock adjusted to 14 units."

The user avoids navigating nested product menus, and the agent handles the math delta required by the API.

Security and Access Control

Exposing an e-commerce database to an LLM requires strict security guardrails. Truto MCP servers enforce access control at the infrastructure level.

• Method Filtering: By defining config.methods: ["read"] during token creation, you guarantee the LLM cannot mutate store data. It will only see get and list operations in its toolset.
• Tag Filtering: Restrict the server to specific domains. Using config.tags: ["inventory"] ensures the model only sees product and stock endpoints, completely hiding financial and customer data.
• Authentication Requirements: Setting require_api_token_auth: true forces the connecting client to pass a valid Truto API token in the headers, meaning possession of the MCP URL alone is not enough to access the tools.
• Time-to-Live (TTL): Passing an expires_at datetime schedules a durable alarm that automatically destroys the MCP token and its KV storage entries, perfect for granting temporary access to automated scripts or contractors.

Rethinking E-commerce Automation

Connecting Ecwid to ChatGPT transforms how you manage store operations. Instead of writing custom API scripts or manually navigating admin dashboards to resolve order issues, your team can use conversational commands to read data, update inventory, and recover revenue.

Building this orchestration layer in-house requires constant schema maintenance and rate limit handling. Truto removes the boilerplate entirely. By providing a managed MCP server that dynamically maps Ecwid's complex endpoints into clean, LLM-ready tools, you can deploy AI agents against your e-commerce data in minutes.