Connect Ecwid to Claude: Handle Customers, Reviews, and Marketing

If you need to connect Ecwid to Claude to automate inventory management, handle customer reviews, or trigger marketing campaigns, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's function-calling capabilities and Ecwid's REST API. You can either build, host, and patch this integration 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 connecting Ecwid to ChatGPT or explore our broader architectural overview on connecting Ecwid to AI Agents.

Giving a Large Language Model (LLM) read and write access to an active e-commerce database like Ecwid is an engineering challenge. You must handle strict authentication protocols, map massive JSON product schemas to MCP tool definitions, and deal with Ecwid's specific rate limits. Every time Ecwid updates an endpoint or deprecates a catalog field, 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 Ecwid, connect it natively to Claude Desktop, and execute complex e-commerce 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 tools, the reality of implementing it against vendor APIs is painful. You are not just integrating "an API" - you are integrating Ecwid's specific quirks, error formats, and architectural decisions.

If you decide to build a custom MCP server for Ecwid, you own the entire API lifecycle. Here are the specific challenges you will face:

The Mandatory Store ID Parameter Almost every endpoint in the Ecwid REST API requires a store_id path parameter. If an LLM attempts to interact with standard CRUD endpoints without this mandatory path parameter, the request instantly fails. When building a custom MCP server, you have to inject this context into every single LLM tool call, which often confuses models that expect flattened global endpoints. Truto handles this by binding the store ID context explicitly into the dynamic tool schemas, ensuring the LLM always provides the correct routing data.

Deeply Nested Catalog Hierarchies Ecwid's catalog schema is highly nested. A single Product entity contains complex nested arrays for options, galleryImages, and combinations (which represent product variations like size and color). When writing back inventory adjustments via an endpoint like ecwid_product_variation_adjust_stock, the model must precisely map the combination_id to the parent product_id. Exposing this raw structure to an LLM often results in hallucinated payload structures. Truto normalizes these nested schemas into standardized JSON Schema definitions, enforcing required fields and providing explicit LLM instructions for handling deeply nested objects.

Rate Limiting and Standardized Headers Ecwid throttles API requests based on plan tiers, and exceeding these limits results in an HTTP 429 Too Many Requests error. A common mistake when building custom MCP servers is attempting to absorb these errors by holding connections open, applying silent exponential backoffs, or retrying indefinitely. Doing so in an AI-agent loop causes silent timeouts and unpredictable execution states.

Truto does not retry, throttle, or apply backoff on rate limit errors. When Ecwid returns a 429, Truto immediately passes that error back to the caller. Crucially, Truto normalizes the upstream limit data into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) following the IETF specification. The agent or LLM client is fully responsible for reading these headers and executing its own intelligent backoff strategy.

How to Generate an Ecwid MCP Server with Truto

Truto's MCP architecture derives tool definitions dynamically from the integration's resource definitions and schema documentation. Rather than hand-coding endpoints, Truto generates them on the fly.

Each MCP server is fully self-contained within a single URL that encodes cryptographic access tokens. You can generate this server via the Truto UI or programmatically via the API.

Method 1: Creating the MCP Server via the Truto UI

For ad-hoc tasks, administrative usage, or local Claude Desktop testing, you can generate an MCP server directly from your Truto dashboard:

1. Log into your Truto dashboard and navigate to the Integrated Accounts page.
2. Select the connected Ecwid account you want to expose to Claude.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Configure the server parameters (e.g., set the name to "Ecwid Claude Connector", filter to specific tool tags, or set an expiration date).
6. Click Create and securely copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Creating the MCP Server via the API

If you are provisioning AI workspaces programmatically or building multi-tenant AI products, you can generate MCP servers dynamically using the Truto API. This creates a secure token stored in a distributed key-value store, returning a ready-to-use endpoint.

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

curl -X POST https://api.truto.one/api/integrated-account/YOUR_ECWID_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Ecwid Marketing and Ops",
    "config": {
      "methods": ["read", "write", "custom"]
    },
    "expires_at": "2025-12-31T23:59:59Z"
  }'

The API returns the connection URL:

{
  "id": "mcp_8f7e6d5c4b3a",
  "name": "Ecwid Marketing and Ops",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": "2025-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890abcdef..."
}

How to Connect the Ecwid MCP Server to Claude

Once you have your Truto MCP server URL, you must connect it to your LLM client. The MCP protocol handles the entire handshake - initializing the connection, requesting the available tool schemas, and formatting the JSON-RPC execution payloads.

Method A: Via the Claude UI (or ChatGPT)

If your organization uses Enterprise or Team tiers that support custom UI-based connectors:

1. Open your Claude workspace settings.
2. Navigate to Integrations (or Connectors in ChatGPT under Settings -> Apps -> Advanced settings).
3. Click Add MCP Server or Add custom connector.
4. Name the connection (e.g., "Ecwid Production Ops").
5. Paste the Truto MCP URL.
6. Click Add. The model will immediately discover the Ecwid tools and make them available in the chat interface.

Method B: Via Manual Config File (Claude Desktop)

For developers using the Claude Desktop application, you can connect the server by editing the claude_desktop_config.json file. Because Truto's MCP servers communicate over HTTP using Server-Sent Events (SSE), you will use the official @modelcontextprotocol/server-sse proxy to bridge the standard input/output stream to Truto's remote endpoint.

Open your configuration file:

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

Add the following configuration, replacing the URL with your actual Truto MCP URL:

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

Restart Claude Desktop. The application will initialize the SSE connection, and you will see the Ecwid integration appear in your available tools list.

Hero Tools for Ecwid Automation

Truto automatically generates highly descriptive, snake_case tools from the Ecwid integration schema. Because Truto injects cursor pagination instructions directly into the tool descriptions, Claude knows exactly how to handle list endpoints.

Here are the core operations you can execute immediately.

list_all_ecwid_order

Fetches a paginated list of Ecwid orders. The tool returns the full order object including id, total, paymentStatus, fulfillmentStatus, email, createDate, and the nested items array. This is critical for building support agents that need to cross-reference customer emails with recent purchases.

"Fetch the latest orders from my Ecwid store for the customer email alex@example.com. Tell me the fulfillment status of their most recent purchase."

create_a_ecwid_abandoned_cart_order

Converts a recovered abandoned cart directly into a finalized order. This tool requires the store_id and the cart_id. It returns the created order details, allowing agents to process manual recoveries negotiated over support channels.

"Customer alex@example.com just confirmed they want to proceed with their abandoned cart ID 847291. Convert that abandoned cart into an actual order in Ecwid."

update_a_ecwid_product_variation_by_id

Updates a specific product variation (e.g., changing the price or inventory of a specific shirt size). This is a complex endpoint that requires the store_id, product_id, and the variation's id. The model can dynamically update pricing, weight, or SKU data for specific combinations.

"Update the inventory for product ID 10029, variation ID 55581. Set the stock quantity to 15 and adjust the compare-to price to $49.99."

list_all_ecwid_product_review

Retrieves the product reviews left by customers. Returns the id, status, rating, review text, and reviewerInfo. This tool is essential for reputation management agents that need to ingest reviews and analyze sentiment.

"Pull all product reviews from the last 7 days that have a rating of 3 stars or lower. Summarize the main complaints."

ecwid_product_review_bulk_update

Updates the publication status of a specific product review. It requires the store_id, review_id, and the target status (e.g., APPROVED or SPAM).

"Review ID 99281 contains explicit language. Update its status in Ecwid to rejected/spam."

create_a_ecwid_discount_coupon

Generates a new marketing discount code. The tool returns the created coupon ID and code. The LLM can configure the discountType, discount amount, and apply limits.

"Create a new discount coupon in Ecwid called 'WINTER25'. Make it a 15% off discount, valid for repeat customers only, and limit it to 100 total uses."

To see the complete inventory of available Ecwid tools, query schemas, and body structures, visit the Ecwid integration page.

Workflows in Action

By exposing Ecwid's raw API endpoints as individual MCP tools, Claude can chain multiple operations together to execute autonomous workflows. Here is how Claude handles complex e-commerce scenarios.

Scenario 1: Abandoned Cart Recovery and Discount Generation

A store operator wants to identify high-value abandoned carts and generate personalized discount codes to win them back.

"Find all abandoned carts from the last 48 hours where the total value is over $150. For each of these customers, generate a unique 10% off discount coupon, and give me a list of their emails alongside the new coupon codes so I can email them."

Execution flow:

1. Claude calls list_all_ecwid_abandoned_cart and filters the returned array for carts older than 48 hours with a total > 150.
2. For each matching cart, Claude calls create_a_ecwid_discount_coupon, dynamically generating a unique code string and setting the discount to 10%.
3. Claude correlates the email from the abandoned cart with the new coupon code and presents the final list to the user.

sequenceDiagram
    participant User as Store Manager
    participant Claude as Claude
    participant MCP as Truto MCP Server
    participant Ecwid as Ecwid API
    User->>Claude: "Find high-value abandoned carts and create discount codes..."
    Claude->>MCP: Call list_all_ecwid_abandoned_cart
    MCP->>Ecwid: GET /<store_id>/profile/abandoned_sales
    Ecwid-->>MCP: Return array of abandoned carts
    MCP-->>Claude: JSON payload with cart data
    Claude->>MCP: Call create_a_ecwid_discount_coupon (Loop)
    MCP->>Ecwid: POST /<store_id>/discount_coupons
    Ecwid-->>MCP: Return coupon metadata
    MCP-->>Claude: JSON payload with coupon code
    Claude-->>User: Present list of emails and new codes

Scenario 2: Autonomous Review Moderation

A support team wants Claude to triage pending product reviews, analyzing sentiment and taking immediate action in the Ecwid database.

"Check Ecwid for any pending product reviews. If the review is 4 or 5 stars and contains no inappropriate language, approve and publish it. If the review is 1 or 2 stars, leave it pending but summarize the complaint for me. If the review contains spam links, delete it."

Execution flow:

1. Claude calls list_all_ecwid_product_review to retrieve reviews currently marked as pending.
2. Claude analyzes the review text payload and the rating integer using its internal reasoning.
3. For high-quality positive reviews, Claude calls ecwid_product_review_bulk_update to change the status to approved.
4. For spam reviews, Claude calls delete_a_ecwid_product_review_by_id.
5. Claude compiles a summary of the remaining critical reviews and presents them to the human operator.

Security and Access Control

Exposing write access to an active e-commerce database requires strict governance. Truto's MCP servers provide granular access controls enforced at the token level, ensuring your AI agents cannot exceed their intended scope.

• Method Filtering: When generating the server, you can pass methods: ["read"] in the configuration. This strictly disables POST, PUT, PATCH, and DELETE operations. Truto enforces this during tool generation - if a tool requires a write method, it is entirely omitted from the schema sent to Claude.
• Tag Filtering: You can restrict the server to specific operational domains. By passing tags: ["marketing"], the server will only expose endpoints related to discounts, promotions, and campaigns, hiding sensitive endpoints like staff accounts or raw order financials.
• Expiration (TTL): The expires_at parameter allows you to create ephemeral servers. Truto provisions an alarm in its distributed architecture; once the timestamp is reached, the token is permanently purged, instantly revoking Claude's access.
• API Token Auth: By default, possessing the MCP server URL grants access. By enabling require_api_token_auth: true, Truto forces the client to pass a valid Truto API bearer token in the headers, adding a secondary layer of authentication for enterprise deployments.

Moving Faster with Managed MCP

Building a custom integration for Ecwid means spending weeks handling nested catalog schemas, routing store_id parameters, and managing rate limit backoff logic. Truto eliminates this boilerplate. By dynamically generating MCP tools from live documentation and strictly mapping API boundaries, you can give Claude safe, reliable access to your Ecwid store in minutes.

Stop writing integration code and start automating your e-commerce operations.