Connect Wix to Claude: Automate Blogs, Bookings, and Messaging

If you need to connect Wix to Claude to automate e-commerce operations, publish blog content, manage bookings, or oversee customer communications, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Wix'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-wix-to-chatgpt-manage-products-orders-and-customers/ or explore our broader architectural overview on /connect-wix-to-ai-agents-sync-data-items-and-site-tasks/.

Giving a Large Language Model (LLM) read and write access to a sprawling business management ecosystem like Wix is an engineering challenge. You have to handle OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Wix's strict API quotas. Every time Wix updates an endpoint or deprecates a V1 resource, 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 Wix, connect it natively to Claude Desktop, and execute complex workflows using natural language.

The Engineering Reality of the Wix 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 Wix's APIs is painful. You are not just integrating "Wix" - you are integrating Wix Stores, Wix Bookings, Wix CRM, and Wix Blog, all of which act as independent microservices with different design patterns.

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

Fragmented API Versions and Endpoints Wix has been migrating its legacy V1 and V2 APIs to its newer V3 architecture. As a result, you will find endpoints scattered across versions depending on the domain. Wix Stores uses V3 for querying products, but still heavily relies on V1 for certain order fulfillment operations. An LLM has no context on which API version to use. You must build an abstraction layer that presents a unified set of operations to Claude, hiding the underlying endpoint fragmentation.

Complex Pagination and Async Jobs Wix handles massive datasets using distinct pagination schemes. Some endpoints require traditional cursor-based pagination, while others rely on heavy asynchronous jobs for data extraction. If you expose raw async job IDs to Claude, the model will struggle to poll the endpoint, parse the status, and retrieve the final payload. Truto normalizes standard pagination into a predictable limit and next_cursor schema, explicitly instructing the LLM to pass cursor values back unchanged.

Strict Rate Limiting and Backoff Logic Wix enforces aggressive rate limits across its ecosystem. If an AI agent attempts to iterate through hundreds of contacts or bulk-update product inventory too quickly, the API will reject the requests. Truto does not intercept or absorb these rate limit errors. Instead, when the Wix API returns an HTTP 429 Too Many Requests, Truto passes that error directly through to Claude, normalizing the upstream rate limit data into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. The caller (the agent or framework) is strictly responsible for implementing exponential backoff and retry logic based on those headers.

sequenceDiagram
  participant Claude as Claude Desktop
  participant MCP as Truto MCP Server
  participant Wix as Wix API

  Claude->>MCP: Call tools/call (wix_products_v_3_query)
  MCP->>Wix: POST /stores/v3/products/query
  Wix-->>MCP: HTTP 429 Too Many Requests
  MCP-->>Claude: JSON-RPC Error (429 + ratelimit-reset)
  Note over Claude: Claude reads reset time<br>and schedules retry
  Claude->>MCP: Call tools/call (retry)
  MCP->>Wix: POST /stores/v3/products/query
  Wix-->>MCP: 200 OK (Product data)
  MCP-->>Claude: JSON-RPC Result

Generating a Wix MCP Server

Rather than writing boilerplate JSON-RPC handlers and OAuth flows, you can generate a Wix MCP server instantly. Truto derives the available tools directly from the connected Wix account's API definitions—a core benefit of using auto-generated MCP tools.

There are two ways to provision an MCP server for your connected Wix account: via the Truto dashboard or programmatically via the API.

Method 1: Via the Truto UI

For internal use cases and quick testing, the UI is the fastest path.

1. Log into your Truto account and navigate to the integrated account page for your active Wix connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., allow read and write methods, filter by tags like ecommerce or crm).
5. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the REST API

If you are building an AI product and need to generate MCP servers dynamically for your end-users, you use the Truto API. This creates a secure token tied specifically to that tenant's Wix instance.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Wix Commerce & CRM Automation",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["ecommerce", "crm", "blog"]
    }
  }'

The API response returns the fully qualified JSON-RPC URL containing the cryptographic token required to authenticate the MCP session.

{
  "id": "mcp_srv_9x8y7z6",
  "name": "Wix Commerce & CRM Automation",
  "config": {
    "methods": ["read", "write", "custom"],
    "tags": ["ecommerce", "crm", "blog"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/f8e7d6c5b4a3..."
}

Connecting the MCP Server to Claude

Once you have the generated URL, you must register it with your LLM client. Claude provides two ways to connect remote MCP servers.

Method 1: Via the Claude UI

If you are using Claude for Enterprise or Claude Desktop with UI configuration enabled:

1. Open Claude and navigate to Settings.
2. Locate the Integrations or Custom Connectors section.
3. Click Add MCP Server.
4. Provide a descriptive name (e.g., "Wix API").
5. Paste the Truto MCP URL into the Server URL field.
6. Click Add. Claude will perform an initialization handshake to fetch the available tools.

Method 2: Via Manual Configuration File

For local development or standard Claude Desktop installations, you define the server using the claude_desktop_config.json file. Since Truto MCP servers speak JSON-RPC over Server-Sent Events (SSE), you use the official @modelcontextprotocol/server-sse transport bridge.

Open your config file:

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

Add the wix-truto entry to your mcpServers object:

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

Restart Claude Desktop. The agent will read the config, establish an SSE connection to Truto, and automatically register the Wix tools.

MCP Deployment Guide: Wix + Claude for Blogs and Bookings

Before you dive into the full end-to-end tutorial below, use this deployment guide as a compact checklist for taking a Wix + Claude MCP setup from a blank Truto workspace to a production automation that handles both blog content and Wix Bookings from a single Claude connector.

The deployment splits cleanly into four phases: connect, scope, wire, and operate. Each phase has a clear exit criterion, so you know when it's safe to move to the next one.

Phase 1: Connect the Wix Account to Truto

Goal: produce a stable integrated_account_id that Truto can use to talk to Wix on the user's behalf.

1. Install the Wix Blog app and the Wix Bookings app on the target site. Blog tools will not appear in tools/list if Blog is not installed, and the Wix Bookings APIs require Bookings to be installed on the site before any endpoint responds.
2. Create a Wix OAuth app (Business or Headless tier) and register it in Truto as the credential source for the Wix integration.
3. From your backend, mint a Truto Link token for the end user and hand them the hosted OAuth flow. Once they consent, Truto stores the refresh token and rotates it shortly before expiry so no run fails on a stale token.
4. Record the returned integrated_account_id. This is the only Wix identifier the rest of the deployment needs.

Exit criterion: calling GET /integrated-account/{id} returns status: connected.

Phase 2: Scope the MCP Server for Blogs and Bookings

Goal: produce a single MCP URL that exposes exactly the blog and bookings surface area - nothing more.

You have a design choice here: one combined MCP server, or two separate servers (one per domain). Use the table below to decide.

For the combined pattern, provision the server with both tags and both read/write access. Booking cancellation and blog draft creation are write operations, so you need write in the method list.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Wix Blog + Bookings Autopilot",
    "config": {
      "methods": ["read", "write"],
      "tags": ["blog", "bookings"],
      "require_api_token_auth": true
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

Exit criterion: a raw tools/list call against the returned URL lists both blog tools (e.g. list_all_wix_posts, create_a_wix_draft_post) and booking tools (e.g. wix_bookings_query, wix_bookings_cancel).

Phase 3: Wire Claude to the MCP URL

Goal: Claude discovers the Wix tools and can invoke them end-to-end.

Choose the wiring path that matches how the automation will actually run:

• Interactive editorial or ops work → Claude Desktop or Claude on the web. Add the URL as a custom connector under Settings → Connectors → Add custom connector. If require_api_token_auth is on, use the SSE bridge and pass the Truto API token as a bearer header.
• Headless / scheduled automation → Anthropic Messages API. Skip the local bridge entirely. Pass the URL through the mcp_servers array on the beta Messages endpoint and set authorization_token to your Truto API key. This is the path the code walkthrough below uses.
• Team-wide rollout → Team or Enterprise custom connector. An org owner registers the connector at the organization level once, then any teammate can invoke it from Claude on the web without editing config files.

Exit criterion: the Claude client shows the Wix tools registered, and a smoke-test prompt like "list my three most recent Wix blog posts" returns real data.

Phase 4: Operate the Pipeline

Goal: keep the connector healthy in production.

• Rotate credentials with expires_at. For scheduled jobs, provision a fresh MCP server per run with a short TTL (one hour is plenty) so a leaked URL cannot be replayed. The token and its metadata are purged automatically once the timestamp passes.
• Log every tool call. When calling through the Messages API, walk the response content array and record each mcp_tool_use and mcp_tool_result block. This is how you tell whether a booking was actually cancelled or a draft was actually staged.
• Handle 429 at the caller. Truto surfaces upstream rate limits as-is with standardized ratelimit-* headers. Your agent loop (or a wrapper around the Messages API) needs a simple exponential backoff keyed off ratelimit-reset.
• Watch for OAuth failure signals. A sudden burst of 401 responses on mcp_tool_result blocks almost always means the user revoked the Wix connection. Route those events back into your Truto Link reconnect flow.

Exit criterion: the same connector supports both the weekly blogging cron and an ad-hoc "cancel unconfirmed appointments for tomorrow" prompt without human babysitting.

End-to-End Tutorial: Connect the Wix API to Claude for Automated Blogging

This walkthrough is the shortest path from a fresh Wix site to an autonomous blogging agent inside Claude. The same steps apply to any Wix domain (Bookings, Stores, CRM), but the example focuses on the blog because it is the highest-leverage automation for content teams.

What you will build in the next 15 minutes:

• A Wix account connected to Truto via OAuth 2.0, with refresh tokens managed for you.
• A blog-scoped MCP server URL that Claude can call directly, protected by an additional API-token check.
• A registered connector inside Claude Desktop that auto-discovers tools like list_all_wix_posts, wix_posts_query, and create_a_wix_draft_post.
• A single-prompt workflow that researches your existing content, drafts a new post, and stages it in your Wix CMS.
• A headless variant of that same workflow using the Anthropic Messages API, runnable from any cron or job runner.

Prerequisites

• A Truto account with an API key (grab it from Settings → API Keys in the Truto dashboard).
• A Wix site with the Business or Headless tier that supports OAuth apps.
• Either Claude Desktop installed, or an Anthropic API key if you plan to run the agent programmatically.

Step 1: Connect the Wix Account

Truto brokers the OAuth 2.0 handshake with Wix. Rather than exchanging tokens yourself, you launch a hosted link flow that returns an integrated_account_id once the user consents.

curl -X POST https://api.truto.one/link-token \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "integration": "wix",
    "end_user": {
      "id": "user_123",
      "name": "Acme Blog Team"
    }
  }'

Send the returned link_token to your frontend, open the Truto Link UI, and let the user complete the Wix consent screen. Truto persists the refresh token and refreshes it shortly before expiry, so your agent never sees an authentication failure mid-run.

Step 2: Generate a Blog-Scoped MCP Server

You want the agent restricted to blog resources so it cannot accidentally mutate orders or bookings. Scope the server with the blog tag and allow both read and write methods. Setting require_api_token_auth: true adds a second authentication layer, so the MCP URL is useless without a valid Truto API token.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Wix Blog Autopilot",
    "config": {
      "methods": ["read", "write"],
      "tags": ["blog"],
      "require_api_token_auth": true
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The response returns the MCP URL you will hand to Claude:

{
  "id": "mcp_srv_blog_9x8",
  "name": "Wix Blog Autopilot",
  "config": {
    "methods": ["read", "write"],
    "tags": ["blog"],
    "require_api_token_auth": true
  },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/f8e7d6c5b4a3..."
}

Step 3: Verify Tool Discovery With a tools/list Call

Before involving Claude, confirm the MCP server exposes the blog tools you expect. Send a raw JSON-RPC tools/list request straight to the endpoint.

curl -X POST https://api.truto.one/mcp/f8e7d6c5b4a3... \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list"
  }'

You should see tools like list_all_wix_posts, create_a_wix_draft_post, wix_posts_query, and list_all_wix_categories returned, each with a full JSON Schema for its parameters. If a tool you expected is missing, the resource likely lacks a documentation record in Truto - only documented endpoints appear as MCP tools.

Step 4: Register the Server With Claude Desktop

Open claude_desktop_config.json and add the blog server. Because require_api_token_auth is on, pass the Truto API token as a bearer header on the SSE bridge.

{
  "mcpServers": {
    "wix-blog": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/f8e7d6c5b4a3...",
        "--header",
        "Authorization: Bearer YOUR_TRUTO_API_KEY"
      ]
    }
  }
}

Restart Claude Desktop. In the MCP indicator you should see the Wix blog tools registered automatically.

Step 5: Run the Automated Blogging Prompt

With the server live, drop a single prompt into Claude that chains research, drafting, and staging in one turn:

"Read the last 10 posts from my Wix blog using list_all_wix_posts. Identify a content gap around customer retention, then draft an 800-word post titled 'How Wix Store Owners Retain Buyers in 2026'. Save it as a draft via create_a_wix_draft_post with tags ['retention', 'ecommerce'] and the 'Industry News' category."

Claude walks the tools in order: it pulls existing posts, reasons over the gap, generates the body, and calls create_a_wix_draft_post with a structured payload. The final response is a link to the draft inside your Wix dashboard.

Step 6: Trigger the Same Flow via the Anthropic API

For scheduled or headless automation (for example, a weekly cron that stages a post every Monday morning), skip Claude Desktop and call the Anthropic Messages API with the MCP URL passed as a connector. The mcp_servers array on the beta Messages endpoint accepts a remote URL and an authorization token, so no local transport bridge is needed.

import Anthropic from '@anthropic-ai/sdk'
 
const client = new Anthropic()
 
const response = await client.beta.messages.create({
  model: 'claude-sonnet-4-5',
  max_tokens: 4096,
  mcp_servers: [
    {
      type: 'url',
      url: 'https://api.truto.one/mcp/f8e7d6c5b4a3...',
      name: 'wix-blog',
      authorization_token: process.env.TRUTO_API_KEY,
    },
  ],
  messages: [
    {
      role: 'user',
      content:
        'Review my last 10 Wix blog posts using list_all_wix_posts. Draft a new 800-word post on a topic we have not covered yet and stage it as a Wix draft with SEO-friendly tags.',
    },
  ],
  betas: ['mcp-client-2025-04-04'],
})
 
console.log(response.content)

The same call in Python:

import os
import anthropic
 
client = anthropic.Anthropic()
 
response = client.beta.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=4096,
    mcp_servers=[
        {
            "type": "url",
            "url": "https://api.truto.one/mcp/f8e7d6c5b4a3...",
            "name": "wix-blog",
            "authorization_token": os.environ["TRUTO_API_KEY"],
        }
    ],
    messages=[
        {
            "role": "user",
            "content": (
                "Review my last 10 Wix blog posts using list_all_wix_posts. "
                "Draft a new 800-word post on a topic we have not covered yet "
                "and stage it as a Wix draft with SEO-friendly tags."
            ),
        }
    ],
    betas=["mcp-client-2025-04-04"],
)
 
print(response.content)

Schedule this script on any cron runner and you have an autonomous blogging pipeline: research pulled from your existing content, drafts staged in Wix with clean metadata, and a human editor who only needs to click Publish.

Step 7: Troubleshoot a Broken Pipeline

Most failures on this pipeline fall into four buckets. Work through them in order before assuming an integration bug.

• Claude cannot see the Wix tools after restart. Confirm the SSE bridge process is running and that the URL in claude_desktop_config.json matches the url field from the MCP creation response exactly. A trailing whitespace character will silently break the JSON-RPC handshake.
• tools/list returns an empty array. The tags filter on your MCP server is likely too narrow. Re-issue the creation call with tags: ["blog"] alone (no additional filters) and confirm the Wix account has the Blog app installed and authorized during the OAuth consent step.
• Claude receives a 401 from the MCP endpoint. You enabled require_api_token_auth: true but the bridge is not forwarding the Authorization header. Re-check the --header argument in the config, or move to the Anthropic Messages API path in Step 6, which passes authorization_token explicitly.
• The draft post call succeeds but the post is missing in Wix. Wix stages drafts under a specific member ID. Confirm the OAuth token used during Step 1 belonged to a member with authoring permissions on the target blog, and check the Drafts tab (not Published) inside the Wix dashboard.

End-to-End Code Walkthrough: Automating Wix Drafts with Claude

The snippets above show each stage in isolation. In production, you want one runnable script that provisions a scoped MCP server on demand, hands it to Claude, and prints exactly which Wix tools the agent invoked. The example below stitches those steps into a single Node.js file you can drop into a cron job, a queue worker, or a package.json script.

The design goals of this script:

• Ephemeral credentials. A fresh MCP server is provisioned per run with a short expires_at, so a leaked URL cannot be replayed a day later.
• Blog-only scope. The server is locked to the blog tag and read + write methods, so Claude physically cannot touch orders, bookings, or contacts.
• Observable tool calls. The script walks the response content array so you can log every mcp_tool_use and mcp_tool_result block Claude produced, which is essential for debugging why a draft did or did not land in Wix.

The Runnable Script

Save the following as wix-blog-agent.ts. It needs three environment variables: ANTHROPIC_API_KEY (read by the SDK automatically), TRUTO_API_KEY, and WIX_INTEGRATED_ACCOUNT_ID (the ID returned after the user finished the Truto Link flow in Step 1).

import Anthropic from '@anthropic-ai/sdk'
 
const TRUTO_API_KEY = process.env.TRUTO_API_KEY!
const INTEGRATED_ACCOUNT_ID = process.env.WIX_INTEGRATED_ACCOUNT_ID!
 
type McpServerResponse = {
  id: string
  url: string
  expires_at: string | null
}
 
// 1. Provision a fresh, blog-scoped MCP server that expires in one hour.
async function provisionMcpServer(): Promise<McpServerResponse> {
  const oneHourFromNow = new Date(Date.now() + 60 * 60 * 1000).toISOString()
 
  const res = await fetch(
    `https://api.truto.one/integrated-account/${INTEGRATED_ACCOUNT_ID}/mcp`,
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${TRUTO_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        name: `wix-blog-run-${Date.now()}`,
        config: {
          methods: ['read', 'write'],
          tags: ['blog'],
          require_api_token_auth: true,
        },
        expires_at: oneHourFromNow,
      }),
    }
  )
 
  if (!res.ok) {
    throw new Error(
      `MCP provisioning failed: ${res.status} ${await res.text()}`
    )
  }
 
  return (await res.json()) as McpServerResponse
}
 
// 2. Hand the URL to Claude and let it drive the Wix blog tools end-to-end.
async function runBloggingAgent(mcpUrl: string) {
  const client = new Anthropic()
 
  const instructions = [
    'You are the editorial agent for a Wix-hosted blog.',
    '1. Call list_all_wix_posts and inspect the 10 most recent posts.',
    '2. Identify one uncovered topic in customer retention.',
    '3. Draft an 800-word post: intro, three H2 sections, conclusion.',
    '4. Call create_a_wix_draft_post with tags ["retention", "ecommerce"]',
    '   and category "Industry News".',
    'Return the draft ID and admin URL in your final message.',
  ].join('\n')
 
  return client.beta.messages.create({
    model: 'claude-sonnet-4-5',
    max_tokens: 4096,
    mcp_servers: [
      {
        type: 'url',
        url: mcpUrl,
        name: 'wix-blog',
        authorization_token: TRUTO_API_KEY,
      },
    ],
    messages: [{ role: 'user', content: instructions }],
    betas: ['mcp-client-2025-04-04'],
  })
}
 
// 3. Walk the response so every tool call is auditable.
function logAgentTrace(response: Awaited<ReturnType<typeof runBloggingAgent>>) {
  for (const block of response.content) {
    if (block.type === 'mcp_tool_use') {
      console.log(`→ tool call: ${block.name}`)
      console.log(`  input: ${JSON.stringify(block.input)}`)
    } else if (block.type === 'mcp_tool_result') {
      console.log(`← tool result (is_error=${block.is_error ?? false})`)
    } else if (block.type === 'text') {
      console.log(`\nAgent summary:\n${block.text}\n`)
    }
  }
}
 
;(async () => {
  const server = await provisionMcpServer()
  console.log(`Provisioned MCP server ${server.id} (expires ${server.expires_at})`)
 
  const response = await runBloggingAgent(server.url)
  logAgentTrace(response)
 
  console.log(`stop_reason=${response.stop_reason}`)
})()

Run it with:

ANTHROPIC_API_KEY=... \
TRUTO_API_KEY=... \
WIX_INTEGRATED_ACCOUNT_ID=... \
npx tsx wix-blog-agent.ts

What You Should See in the Logs

A healthy run produces a trace that looks roughly like this:

Provisioned MCP server mcp_srv_blog_9x8 (expires 2026-08-24T16:12:44.000Z)
→ tool call: list_all_wix_posts
  input: {"limit":10,"sort":"-firstPublishedDate"}
← tool result (is_error=false)
→ tool call: create_a_wix_draft_post
  input: {"title":"How Wix Store Owners Retain Buyers in 2026", ...}
← tool result (is_error=false)

Agent summary:
Draft created. ID: 8f2e-... Admin URL: https://manage.wix.com/...

stop_reason=end_turn

If stop_reason is tool_use instead of end_turn, Claude was still mid-plan when it hit max_tokens; either raise the token budget or add a follow-up messages.create call that feeds the previous response.content back in as the assistant turn. If a mcp_tool_result block reports is_error=true, inspect the block's content field for the upstream Wix status code - a 429 means you need to back off, a 401 means the OAuth connection expired and the user needs to reconnect through Truto Link.

Wiring It into a Weekly Cron

Once the script runs cleanly locally, deploying it as a scheduled job is trivial. On a GitHub Actions runner, the workflow is essentially:

name: Weekly Wix Draft
on:
  schedule:
    - cron: '0 13 * * 1' # Monday 13:00 UTC
jobs:
  draft:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20' }
      - run: npm ci
      - run: npx tsx wix-blog-agent.ts
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          TRUTO_API_KEY: ${{ secrets.TRUTO_API_KEY }}
          WIX_INTEGRATED_ACCOUNT_ID: ${{ secrets.WIX_INTEGRATED_ACCOUNT_ID }}

Every Monday morning the runner provisions a one-hour MCP server, invokes Claude, stages a draft in Wix, and disposes of the credential automatically. Your editor opens Wix, reviews the draft in the CMS, and publishes.

Essential Wix Hero Tools

Truto exposes dozens of endpoints across the Wix API. By providing detailed descriptions and JSON schema definitions to the LLM, Claude inherently understands what parameters are required and how to structure payloads. Here are the highest-leverage operations for Wix automation.

wix_products_v_3_query

Wix's V3 architecture uses a specialized query engine for retrieving store products. This tool allows Claude to fetch items using advanced sorting, filtering, and field selection.

Contextual usage: Use this when checking inventory levels, auditing pricing, or finding specific SKUs before applying discounts.

"Query my Wix V3 store products. Find all items where the inventory level is below 10 units, and output a table with the product name, SKU, and remaining stock."

wix_bookings_query

Wix Bookings is notoriously complex, handling staff availability, service types, and calendar slots. This tool exposes the booking query engine to the agent.

Contextual usage: Use this for auditing upcoming appointments, finding schedule gaps, or cross-referencing bookings with CRM contact records.

"Query all confirmed Wix Bookings for next week. Group them by the assigned staff member and list the customer's name and service requested."

create_a_wix_draft_post

Instead of copy-pasting AI output into the Wix dashboard, Claude can push content directly to the CMS as a draft. The schema supports structured blog data including tags, categories, and SEO metadata.

Contextual usage: Perfect for autonomous content generation pipelines where the LLM researches a topic, formats the markdown, and stages the post for human review.

"Draft a new blog post in Wix titled 'Top 5 E-Commerce Trends for 2026'. Include an introduction, three main sections, and assign it to the 'Industry News' category."

list_all_wix_orders

This tool retrieves e-commerce orders, providing full visibility into transaction states, fulfillment status, and line items.

Contextual usage: Use this for financial reconciliation, generating daily sales reports, or checking if high-value customers have pending shipments.

"List all Wix store orders from the past 48 hours that are marked as 'paid' but not yet 'fulfilled'. Calculate the total revenue from these pending orders."

list_all_wix_contacts

Wix CRM is the central nervous system of a Wix business. This tool exposes customer profiles, enabling the agent to search for site members, newsletter subscribers, and buyers.

Contextual usage: Critical for audience segmentation, finding contact IDs for messaging workflows, or identifying duplicate records.

"Find all Wix contacts who have the label 'VIP Customer' and extract their primary email addresses for our upcoming outreach campaign."

create_a_wix_conversation

Integrates directly with the Wix Inbox. This tool allows Claude to initiate direct messaging threads with site visitors or logged-in members.

Contextual usage: Ideal for automated support triage, sending follow-up messages after a booking, or recovering abandoned carts.

"Create a new Wix Inbox conversation with contact ID 'contact-123'. Send them a message thanking them for their recent purchase and asking if they need help with setup."

For the complete inventory of available tools, query parameters, and schema definitions, reference the Wix integration page.

Workflows in Action

When you combine these tools within Claude's context window, you unlock multi-step reasoning capabilities. The agent can read data, synthesize an action plan, and execute writes back to the Wix API without human intervention.

Scenario 1: Autonomous E-Commerce Inventory & Outreach

Persona: Store Owner

"Check my Wix store for any products with less than 5 items in stock. For each low-stock item, find all customers who purchased it in the last month and draft an email to them offering a 10% discount on their next order of that product."

1. wix_products_v_3_query: Claude queries the product catalog with an inventory filter (stock.quantity < 5) to identify depleted SKUs.
2. list_all_wix_orders: The model searches recent orders, filtering for those containing the specific low-stock product IDs.
3. list_all_wix_contacts: Claude resolves the customer IDs from the orders into actual CRM contact records to get email addresses and names.
4. create_a_wix_conversation: The agent initiates a direct message thread via the Wix Inbox to each identified customer containing the personalized discount copy.

Outcome: Proactive customer retention executed end-to-end. The store owner gets higher engagement on low-stock items while Claude handles the cross-referencing and messaging.

Scenario 2: Service Booking Triage and Schedule Management

Persona: Service Provider / Operations Manager

"Audit my Wix Bookings for tomorrow. If there are any unconfirmed appointments, cancel them. Then, find the contacts for the remaining confirmed bookings and send them a reminder message via Wix Inbox."

1. wix_bookings_query: Claude retrieves the schedule for the next 24 hours, analyzing the status of each appointment.
2. wix_bookings_cancel: For any booking in a 'pending' or 'unconfirmed' state, the model triggers the cancellation tool.
3. list_all_wix_contacts: Claude pulls the contact details for the clients tied to the remaining 'confirmed' bookings.
4. create_a_wix_conversation: The agent dispatches a pre-formatted reminder message to the clients' inboxes.

Outcome: An automated daily operations routine. The agent cleans up the schedule, frees up unconfirmed time slots, and ensures paying clients receive timely reminders.

Scenario 3: AI-Driven Content Marketing Pipeline

Persona: Content Manager

"Review our last 5 published Wix blog posts to analyze our current topics. Based on that, draft a new, original 800-word blog post about 'The Future of Sustainable Retail'. Save it as a draft and apply relevant tags."

1. wix_posts_query: Claude reads the live blog endpoints to index recent article titles and metadata, ensuring the new content isn't redundant.
2. Claude Internal Processing: The model synthesizes the requested topic, writes the article in markdown, and structures the metadata payload.
3. create_a_wix_draft_post: The agent calls the creation tool, passing the generated content, a localized title, and tags like ['sustainability', 'retail'] directly into the Wix CMS.

Outcome: An entire content pipeline collapsed into a single prompt. The human editor simply logs into Wix, reviews the staged draft, and clicks publish.

graph TD
    A["User Prompt:<br>'Analyze past blogs and draft a new one'"] --> B["wix_posts_query"]
    B --> C["Claude generates<br>markdown content"]
    C --> D["create_a_wix_draft_post"]
    D --> E["Wix CMS<br>(Draft Saved)"]

Security and Access Control

Connecting an autonomous agent to your business operations requires strict governance. Truto MCP servers provide granular, configuration-driven security controls at the server level.

• Method Filtering: Limit what the LLM can do based on the task. By passing config.methods: ["read"] during server creation, you guarantee the agent can only fetch data (e.g., list_all_wix_orders). It is architecturally impossible for the LLM to mutate state or trigger a write operation.
• Tag Filtering: Restrict access to specific functional areas of Wix. Using config.tags: ["crm"] scopes the MCP server entirely to contacts and conversations, blocking access to product catalogs or financial data.
• Mandatory Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. For production deployments, enabling this flag forces the client to pass a valid Truto API token in the Authorization header. This adds a secondary authentication layer, ensuring that leaked configuration files cannot be exploited.
• Automated Expiration (expires_at): You can assign a strict time-to-live (TTL) to any MCP server. The underlying token is stored in a distributed key-value store, and a distributed scheduling system ensures the token and its associated tools are permanently purged from the database once the expiration timestamp is reached.

Strategic Wrap-Up

The gap between what an AI model knows and what it can execute is defined by integration infrastructure. Writing a custom connector for Wix requires reverse-engineering its fragmented V1/V3 architecture, mapping highly nested JSON schemas, and building manual backoff logic for strict rate limits.

By leveraging Truto's managed MCP architecture, you replace a massive integration codebase with a single API call. You get dynamically generated, fully documented tools that Claude can consume instantly. Instead of fighting API drift, you can focus entirely on building higher-order agentic workflows that drive revenue and automate operations.