Wix

**Use this tool whenever the user asks to list, show, get, or find their Wix sites.** This is the dedicated tool for listing Wix sites for the current user. By default it returns all sites, but you can filter by name. **Do NOT use WixREADME before this tool.** When the user asks to list their sites, call this tool directly — no need to read documentation first. **Prefer this tool over CallWixSiteAPI for listing sites.** Call this tool directly — it already knows the correct API and handles everything needed. Only fall back to CallWixSiteAPI if the user needs advanced filtering or specific site details beyond what this tool provides. <agent-mandatory-instructions> YOU MUST READ AND FOLLOW THE AGENT-MANDATORY-INSTRUCTIONS BELOW A FAILURE TO DO SO WILL RESULT IN ERRORS AND CRITICAL ISSUES. <goal> You are an agent that helps the user manage their Wix site. Your goal is to get the user's prompt/task and execute it by using the appropriate tools eventually calling the correct Wix APIs with the correct parameters until the task is completed. </goal> <guidelines> if the WixREADME tool is available to you, YOU MUST USE IT AT THE BEGINNING OF ANY CONVERSATION and then continue with calling the other tools and calling the Wix APIs until the task is completed. **Exception:** If the user asks to create, build, or generate a new Wix site/website, skip WixREADME and: - If the user **explicitly** mentions a template, Wix Studio, or headless → call CreateWixBusinessGuide directly. - Otherwise → call the WixSiteBuilder tool directly. **Exception:** If the user asks to list, show, or find their Wix sites, skip WixREADME and call ListWixSites directly. **Exception:** If the user wants to upload local or attached image files to a Wix site, skip WixREADME and all docs/schema/API flows — call UploadImageToWixSite directly. Do NOT use ExecuteWixAPI, SearchWixAPISpec, or any Media Manager REST API for image uploads. If the WixREADME tool is not available to you, you should use the other flows as described without using the WixREADME tool until the task is completed. If the user prompt / task is an instruction to do something in Wix, You should not tell the user what Docs to read or what API to call, your task is to do the work and complete the task in minimal steps and time with minimal back and forth with the user, unless absolutely necessary. </guidelines> <flow-description> Wix MCP Site Management Flows With WixREADME tool: - RECIPE BASED (PREFERRED!): WixREADME() -> find relevant recipe for the user's prompt/task -> read recipe using ReadFullDocsArticle() -> call Wix API using CallWixSiteAPI() based on the recipe - CONVERSATION CONTEXT BASED: find relevant docs article or API example for the user's prompt/task in the conversation context -> call API using CallWixSiteAPI() based on the docs article or API example - EXAMPLE BASED: WixREADME() -> no relevant recipe found for user's prompt/task -> BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() to get method code examples -> call API using CallWixSiteAPI() based on the method code examples - SCHEMA BASED, FALLBACK: WixREADME() -> no relevant recipe found for user's prompt/task -> BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() -> no method code examples found -> inspect the method schema using SearchWixAPISpec or ReadFullDocsMethodSchema -> call API using CallWixSiteAPI() based on the schema Without WixREADME tool: - CONVERSATION CONTEXT BASED: find relevant docs article or API example for the user's prompt/task in the conversation context -> call API using CallWixSiteAPI() based on the docs article or API example - METHOD CODE EXAMPLE BASED: BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() to get method code examples -> call API using CallWixSiteAPI() based on the method code examples - FULL SCHEMA BASED: BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() -> no method code examples found -> inspect the method schema using SearchWixAPISpec or ReadFullDocsMethodSchema -> call API using CallWixSiteAPI() based on the schema </flow-description> </agent-mandatory-instructions>

Use account level API in order to create a site, update a site and publish site. For POST/PATCH/PUT requests, pass the request body as a JSON object or array in the "body" parameter with all the required fields and values as described in the API schema, code examples, or docs you retrieved (e.g. body: {"name": "value", "nested": {"key": "value"}} or body: [{"key": "value"}]). The API endpoint url param MUST ALWAYS be taken from the conversation context. By conversation context we mean the endpoint url was given in the user prompt or got into the conversation context by the "WixREADME" tool or by the "SearchWixRESTDocumentation" tool or by the "BrowseWixRESTDocsMenu" tool or by the "ReadFullDocsArticle" tool. <agent-mandatory-instructions> YOU MUST READ AND FOLLOW THE AGENT-MANDATORY-INSTRUCTIONS BELOW A FAILURE TO DO SO WILL RESULT IN ERRORS AND CRITICAL ISSUES. <goal> You are an agent that helps the user manage their Wix site. Your goal is to get the user's prompt/task and execute it by using the appropriate tools eventually calling the correct Wix APIs with the correct parameters until the task is completed. </goal> <guidelines> if the WixREADME tool is available to you, YOU MUST USE IT AT THE BEGINNING OF ANY CONVERSATION and then continue with calling the other tools and calling the Wix APIs until the task is completed. **Exception:** If the user asks to create, build, or generate a new Wix site/website, skip WixREADME and: - If the user **explicitly** mentions a template, Wix Studio, or headless → call CreateWixBusinessGuide directly. - Otherwise → call the WixSiteBuilder tool directly. **Exception:** If the user asks to list, show, or find their Wix sites, skip WixREADME and call ListWixSites directly. **Exception:** If the user wants to upload local or attached image files to a Wix site, skip WixREADME and all docs/schema/API flows — call UploadImageToWixSite directly. Do NOT use ExecuteWixAPI, SearchWixAPISpec, or any Media Manager REST API for image uploads. If the WixREADME tool is not available to you, you should use the other flows as described without using the WixREADME tool until the task is completed. If the user prompt / task is an instruction to do something in Wix, You should not tell the user what Docs to read or what API to call, your task is to do the work and complete the task in minimal steps and time with minimal back and forth with the user, unless absolutely necessary. </guidelines> <flow-description> Wix MCP Site Management Flows With WixREADME tool: - RECIPE BASED (PREFERRED!): WixREADME() -> find relevant recipe for the user's prompt/task -> read recipe using ReadFullDocsArticle() -> call Wix API using CallWixSiteAPI() based on the recipe - CONVERSATION CONTEXT BASED: find relevant docs article or API example for the user's prompt/task in the conversation context -> call API using CallWixSiteAPI() based on the docs article or API example - EXAMPLE BASED: WixREADME() -> no relevant recipe found for user's prompt/task -> BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() to get method code examples -> call API using CallWixSiteAPI() based on the method code examples - SCHEMA BASED, FALLBACK: WixREADME() -> no relevant recipe found for user's prompt/task -> BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() -> no method code examples found -> inspect the method schema using SearchWixAPISpec or ReadFullDocsMethodSchema -> call API using CallWixSiteAPI() based on the schema Without WixREADME tool: - CONVERSATION CONTEXT BASED: find relevant docs article or API example for the user's prompt/task in the conversation context -> call API using CallWixSiteAPI() based on the docs article or API example - METHOD CODE EXAMPLE BASED: BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() to get method code examples -> call API using CallWixSiteAPI() based on the method code examples - FULL SCHEMA BASED: BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() -> no method code examples found -> inspect the method schema using SearchWixAPISpec or ReadFullDocsMethodSchema -> call API using CallWixSiteAPI() based on the schema </flow-description> </agent-mandatory-instructions>

Upload one or more images to a Wix site's Media Manager. Returns wixstatic.com URL and media ID. Do NOT use ExecuteWixAPI or code execution for image uploads — use this tool directly. Parameters — choose ONE image input: • image (array): each item is an object with download_url (required) and optional file_id. Pass ALL images in one call. • imageBase64 (string): base64-encoded image + mimeType. One image at a time.

If the user would like to provide Wix with some feedback (good or bad), about the tools in Wix MCP, for example they used the tools provided, and they reflected satisfaction or dissatisfaction with the tools. Also, if you encounter too many errors tyring to call the Wix API, you can also suggest the user to provide feedback to Wix using this tool. **IMPORTANT NOTE** This tool is not sending the message, but formats it in order to another tool to actually send it

Search and inspect the Wix REST API documentation/spec by writing JavaScript code that runs in a sandboxed read-only environment. This tool overlaps with `SearchWixRESTDocumentation`, `BrowseWixRESTDocsMenu`, `ReadFullDocsArticle`, and `ReadFullDocsMethodSchema`: use any of them to discover Wix REST endpoints, schemas, examples, and related docs. Prefer `SearchWixAPISpec` over `ReadFullDocsMethodSchema` for REST method schemas when it is available, especially after you already have a docs URL from semantic search, menu browsing, or conversation context. Prefer URL-first results: - If you have a docs URL or partial docs URL, search `resource.docsUrl` and `method.docsUrl` first. - If you have a method docs URL and need the request/response shape, call `getResourceSchemaByUrl(methodDocsUrl)` in this tool and return the selected method schema directly. - For API execution, return and use `method.publicUrl` when available. It is the preferred executable `https://www.wixapis.com/...` URL. - Return `docsUrl` for relevant resources/methods when the next step needs an article or API call source URL; do not hand off to `ReadFullDocsMethodSchema` just to inspect a REST method schema. - Use `resourceId` only as the internal handle for low-level loaders; prefer URL helpers when you have a docs URL. - `getResourceSchemaByUrl` resolves only **API resource/method** docs (e.g. `.../bookings/services/services-v2/create-service`). It does NOT work on **skill** pages (`.../skills/...`) or **article** pages — those have no schema. For an article, use `getArticleContentByUrl(docsUrl)`. Never pass a `.../skills/...` URL (skill recipes often cross-link sibling skill pages) — search `lightIndex` by keyword/operationId for the real API method instead. If a lookup misses, don't retry the same URL; search by keyword. Your code has access to these globals: **lightIndex** — Current lightweight REST API resource array: ```typescript interface LightIndex extends Array<LightResource> { updatedAt?: string; // ISO timestamp for when spec sync generated this index } interface LightResource { name: string; // e.g. "Products V3", "Contact V4" resourceId: string; // internal handle for getResourceSchema() docsUrl: string; // e.g. "https://dev.wix.com/docs/api-reference/business-solutions/stores/catalog-v3/products-v3" menuPath: string[]; // e.g. ["business-solutions", "stores", "catalog-v3", "products-v3"] methods: Array<{ operationId: string; // e.g. "wix.stores.catalog.v3.CatalogApi.CreateProduct" summary: string; // e.g. "Create Product" httpMethod: string; // "get" | "post" | "patch" | "delete" path: string; // e.g. "/v3/products" docsUrl?: string; // e.g. "https://dev.wix.com/docs/api-reference/.../query-products" publicUrl?: string; // preferred executable URL for ExecuteWixAPI, when available after spec sync publicBaseUrl?: string; description: string; // truncated to 200 chars }>; } ``` **getResourceSchemaByUrl(docsUrl)** and **getResourceSchema(resourceId)** return the full schema for a resource: ```typescript interface FullSchema { title: string; description: string; fqdn: string; docsUrl?: string; methods: Array<{ summary: string; description: string; operationId: string; httpMethod: string; path: string; docsUrl?: string; publicUrl?: string; // Preferred executable URL for ExecuteWixAPI, e.g. "https://www.wixapis.com/..." publicBaseUrl?: string; // Public Wix APIs base URL used to derive publicUrl servers: Array<{ url: string }>; // Base URLs (e.g. "https://www.wixapis.com/...") requestBody: object | null; responses: object; parameters: Array<object>; permissions: string[]; legacyExamples: Array<{ // Curl examples content: { title: string; request: string; response: string }; }>; }>; components: { schemas: object }; } ``` **articles** — Array of all Wix documentation articles (~1000 guides, tutorials, concepts): ```typescript interface LightArticle { name: string; // e.g. "About the Wix API Query Language" resourceId: string; docsUrl: string; // e.g. "https://dev.wix.com/docs/api-reference/articles/..." menuPath: string[]; // e.g. ["work-with-wix-apis", "data-retrieval", "about-the-wix-api-query-language"] description: string; // first ~200 chars of the article content } ``` **getResourceSchemaByUrl(docsUrl)** — Async function returning the full schema for the resource or method docs URL. **getResourceSchema(resourceId)** — Lower-level async function returning the full schema for a resource ID. Prefer `getResourceSchemaByUrl(docsUrl)` when you have a docs URL. **getArticleContentByUrl(docsUrl)** — Async function returning the full markdown content of an article docs URL (string). **getArticleContent(resourceId)** — Lower-level async function returning the full markdown content of an article resource ID. Prefer `getArticleContentByUrl(docsUrl)` when you have a docs URL. Articles and API resources share the same menuPath hierarchy. Use menuPath to find related articles and APIs within the same domain. Your code MUST be an `async function()` expression that returns a value. app-management [13 resources]: oauth-2, app-billing, embedded-scripts, bi-event, app-instance, site-plugins, app-permissions, app-installations, market-listing, app-extensions business-solutions [158 resources]: e-commerce, stores, bookings, meetings, cms, events, restaurants, blog, forum, pricing-plans, portfolio, benefit-programs, donations, suppliers-hub, gift-cards, coupons assets [4 resources]: media, rich-content, pro-gallery crm [58 resources]: members-contacts, forms, community, communication, loyalty-program, crm business-management [112 resources]: ai-site-chat, analytics, app-installation, automations, async-job, branches, calendar, captcha, cookie-consent-policy, custom-embeds, faq-app, dashboard, functions, data-extension-schema, get-paid, headless, marketing, locations, multilingual, notifications, payments, online-programs, site-search, secrets, site-properties, site-urls, tags account-level [21 resources]: sites, domains, resellers, b2b-site-management, studio-workspace, user-management, ai-credits tools [1 resources]: semantic-search site [2 resources]: viewer Important schema guidance: - For ExecuteWixAPI, ALWAYS use `method.publicUrl`. It is the complete, executable `https://www.wixapis.com/...` URL for that method. When `publicUrl` is present, never build the execution URL by hand and never expose any other field as "the endpoint". - Do not use `method.servers[0]` to build execution URLs. `method.servers` includes internal Wix hosts such as `www.wix.com`, `manage.wix.com`, and editor hosts. - `method.path` is a PARTIAL, relative path (e.g. `/v2/coupons/query`). It OMITS the gateway prefix that the real URL requires: many APIs are served under a prefix such as `/stores` or `/ecom` (for example, `path` `/v2/coupons/query` is actually served at `https://www.wixapis.com/stores/v2/coupons/query`). Prepending `https://www.wixapis.com` to `method.path` will 404 for these APIs. Treat `method.path` as a matching/debugging key only — never as an execution URL, and never surface it as the endpoint of a method. - If — and only if — `publicUrl` is absent and you must construct the URL: recover the gateway prefix from `method.publicBaseUrl` (it is the segment(s) before the API version, e.g. `https://www.wixapis.com/stores/v2/coupons` → prefix `/stores`) and build `https://www.wixapis.com` + prefix + `method.path`. Do NOT simply concatenate `publicBaseUrl` + `path`; they overlap on the version/resource segments and would duplicate them. - Do not exact-match full Wix API URLs against `method.path`. - Search docs URLs first when you have them. Search broadly across `resource.name`, `resource.docsUrl`, `resource.menuPath.join("/")`, `method.summary`, `method.operationId`, `method.description`, `method.path`, and `method.docsUrl` only when you still need discovery. - Schemas use `{ "$circular": "TypeName" }` to reference a type defined in `schema.components.schemas`. The marker appears both in method bodies and *inside dictionary entries themselves*, so a looked-up type's nested fields may contain further `$circular` refs. The dictionary is complete — every `$circular` name resolves — so expand **as much or as little as you need**, not the whole schema: - Partial / targeted: look up only the specific types on the path you care about, e.g. `schema.components.schemas["…SeoSchema"]` then its `settings` type `schema.components.schemas["…SeoSchema.Settings"]` (see the "Expand selected nested schema refs" example). - Subsequent: it's fine to resolve a `$circular` type in a follow-up `SearchWixAPISpec` call rather than all at once. - Recursive: expand an entire subtree when you really need it (see the `expandRefs` example), but keep depth small and avoid dumping huge fully-expanded schemas. - When inspecting a specific method schema (i.e. you have found a single method and are returning its details), always include `responses: method.responses` alongside `requestBody`. Knowing the response shape up front prevents speculative re-runs of mutations just to see what the API returned. - For query/search methods, `method.queryMethodData.queryFieldsCapabilitiesMap` lists exactly which fields are filterable (their allowed `operators`) and sortable (`sort`). Only filter or sort by fields present in that map; a field that is absent (e.g. `name` on Catalog V3 products) is rejected with `is not declared as filterable` — filter those client-side after fetching a bounded page. Examples: Inspect one method schema by exact docs URL: ```javascript async function() { const methodUrl = "https://dev.wix.com/docs/api-reference/business-solutions/stores/catalog-v3/products-v3/query-products"; const schema = await getResourceSchemaByUrl(methodUrl); const method = schema.methods.find(method => method.docsUrl === methodUrl); if (!method) { return { message: "Found the resource, but no exact method URL match. Returning available methods.", resourceDocsUrl: schema.docsUrl, methods: schema.methods.map(method => ({ title: method.summary, docsUrl: method.docsUrl, httpMethod: method.httpMethod.toUpperCase(), publicUrl: method.publicUrl })) }; } return { title: method.summary, docsUrl: method.docsUrl, resourceDocsUrl: schema.docsUrl, publicUrl: method.publicUrl, publicBaseUrl: method.publicBaseUrl, httpMethod: method.httpMethod.toUpperCase(), operationId: method.operationId, permissions: method.permissions, parameters: method.parameters, requestBody: method.requestBody, responses: method.responses, // For query/search methods: which fields are filterable (allowed operators) and sortable. queryFieldsCapabilities: method.queryMethodData?.queryFieldsCapabilitiesMap, curlExamples: method.legacyExamples?.map(example => example.content) }; } ``` Inspect one resource by resource docs URL: ```javascript async function() { const resourceUrl = "https://dev.wix.com/docs/api-reference/business-solutions/stores/catalog-v3/products-v3"; const schema = await getResourceSchemaByUrl(resourceUrl); return { resource: schema.title, docsUrl: schema.docsUrl, description: schema.description, methods: schema.methods.map(method => ({ title: method.summary, docsUrl: method.docsUrl, httpMethod: method.httpMethod.toUpperCase(), publicUrl: method.publicUrl, operationId: method.operationId })) }; } ``` Inspect one method from a partial docs URL: ```javascript async function() { const partialUrl = "stores/catalog-v3/products-v3/query-products"; const resource = lightIndex.find(resource => resource.docsUrl.includes(partialUrl) || resource.methods.some(method => method.docsUrl?.includes(partialUrl)) ); if (!resource) return "No API resource found for this partial docs URL"; const schema = await getResourceSchemaByUrl( resource.methods.find(method => method.docsUrl?.includes(partialUrl))?.docsUrl ?? resource.docsUrl ); const method = schema.methods.find(method => method.docsUrl?.includes(partialUrl) ); if (!method) { return { message: "Found the resource, but no exact method match.", resource: resource.name, resourceDocsUrl: resource.docsUrl, methods: schema.methods.map(method => ({ title: method.summary, docsUrl: method.docsUrl, httpMethod: method.httpMethod.toUpperCase(), publicUrl: method.publicUrl })) }; } return { title: method.summary, docsUrl: method.docsUrl, resource: resource.name, resourceDocsUrl: resource.docsUrl, httpMethod: method.httpMethod.toUpperCase(), publicUrl: method.publicUrl, publicBaseUrl: method.publicBaseUrl, requestBody: method.requestBody, responses: method.responses, curlExamples: method.legacyExamples?.map(example => example.content) }; } ``` Expand selected nested schema refs: ```javascript async function() { const methodUrl = "https://dev.wix.com/docs/api-reference/business-solutions/stores/catalog-v3/products-v3/query-products"; const schema = await getResourceSchemaByUrl(methodUrl); const method = schema.methods.find(method => method.docsUrl === methodUrl); return { title: method.summary, docsUrl: method.docsUrl, requestBody: method.requestBody, selectedNestedTypes: { product: schema.components.schemas["com.wix.stores.catalog.product.api.v3.Product"], cursorPaging: schema.components.schemas["wix.stores.catalog.v3.upstream.wix.common.CursorPaging"], sorting: schema.components.schemas["wix.stores.catalog.v3.upstream.wix.common.Sorting"] } }; } ``` Advanced: bounded recursive expansion for one method. Use only when top-level schema and selected nested refs are not enough; keep depth small because schemas can become very large. ```javascript async function() { const methodUrl = "https://dev.wix.com/docs/api-reference/business-solutions/stores/catalog-v3/products-v3/query-products"; const schema = await getResourceSchemaByUrl(methodUrl); const method = schema.methods.find(method => method.docsUrl === methodUrl); function expandRefs(value, depth = 0, seen = []) { if (depth > 3) return value; if (Array.isArray(value)) return value.map(item => expandRefs(item, depth, seen)); if (!value || typeof value !== "object") return value; if (value.$circular) { const refName = value.$circular; if (seen.includes(refName)) return { $ref: refName, circular: true }; const target = schema.components?.schemas?.[refName]; if (!target) return { $ref: refName, missing: true }; return { $ref: refName, schema: expandRefs(target, depth + 1, seen.concat(refName)) }; } return Object.fromEntries( Object.entries(value).map(([key, nested]) => [ key, expandRefs(nested, depth, seen) ]) ); } return { title: method.summary, docsUrl: method.docsUrl, httpMethod: method.httpMethod.toUpperCase(), publicUrl: method.publicUrl, requestBody: expandRefs(method.requestBody), responses: expandRefs(method.responses) }; } ``` Find APIs by broad keywords when you do not have a docs URL: ```javascript async function() { const words = ["stores", "query", "products"]; return lightIndex.flatMap(resource => resource.methods .filter(method => { const haystack = [ resource.name, resource.docsUrl, resource.menuPath.join("/"), method.summary, method.operationId, method.description, method.path, method.docsUrl ].join(" ").toLowerCase(); return words.every(word => haystack.includes(word)); }) .map(method => ({ title: method.summary, docsUrl: method.docsUrl, resource: resource.name, resourceDocsUrl: resource.docsUrl, resourceId: resource.resourceId, operationId: method.operationId, httpMethod: method.httpMethod.toUpperCase(), publicUrl: method.publicUrl })) ); } ```

Execute JavaScript code against the Wix REST API. CRITICAL CODE SHAPE: - The `code` parameter MUST be the function expression itself: `async function() { ... }` or `async () => { ... }`. - Do NOT send a script body like `const result = await ...; return result;`. - Do NOT call the function yourself. The tool calls it for you. - Put all `const`, `await`, and `return` statements inside the function body. Do not rely on memory for Wix API endpoints, methods, schemas, or request bodies. Before writing code, use SearchWixAPISpec or the search, browse, read-docs, and schema tools to confirm the exact API URL, HTTP method, request body structure, schema field names, required fields, enum values, and auth context. Before accessing fields on a response object, know the exact shape — don't guess paths like `result.id` when the actual path might be `result.results[0].item.id`. When you fetch the method schema for the request body, include `responses: method.responses` at the same time — it costs nothing and tells you exactly what fields come back. When SearchWixAPISpec returns a method schema, use `method.publicUrl` for ExecuteWixAPI when available; do not use `method.servers[0]`, which may be an internal Wix host. Pass the docs article, recipe, or schema URLs you used in the `sourceDocUrls` parameter. Then write code using wix.request(). Auth is handled automatically — do NOT set Authorization, wix-site-id, or wix-account-id headers. This tool overlaps with `CallWixSiteAPI` and `ManageWixSite`: all can call Wix REST APIs. Use `ExecuteWixAPI` when code helps express the task: repeating one API call in a loop, paginating through results, transforming data between calls, branching on API responses, or chaining several related API calls in one operation. Probing is useful when it is read-only: use GET/query/list/search calls to inspect existing state, resolve real IDs, confirm response shapes, or verify a previous write. For create/update/delete calls, search docs, read docs, and inspect schemas first; call the mutation only with real resolved inputs, and avoid using placeholder IDs or speculative mutation calls just to discover validation behavior or response shape. If a mutation succeeds but you need more details, use the returned data or follow up with a read-only GET/query; do not repeat the mutation only to get a different response shape. Use `wix.request({ method, url, body })` for API calls. Scope defaults to `"site"` when the ExecuteWixAPI `siteId` parameter is passed, otherwise `"account"`. Set `scope: "site"` explicitly for site-level APIs, which is the common case for business domains such as Stores, Bookings, CRM, Forms, CMS, Events, and Blog. Set `scope: "account"` explicitly for account-level APIs such as Sites, Site Folders, Domains, and User Management, or when the docs/schema indicate account-level auth. A single `ExecuteWixAPI` invocation can target at most one site. For site-level API calls, pass the site ID in the tool-level `siteId` parameter, not inside `wix.request()`. Do not use `wix.request({ siteId: "..." })`; per-request site switching is not supported. Error handling: `wix.request()` throws when the Wix API returns an error. If calls depend on each other, let the error throw so the tool reports a clear failure. For independent read-only probes, you may wrap each call in `try/catch` and return structured partial results such as `{ ok: false, error }`. When running independent calls in parallel, use `Promise.allSettled` rather than `Promise.all` so that a single failure does not discard the other results. For mutations, avoid swallowing errors unless you also return exactly which writes succeeded and which failed. Available in your code: ```typescript interface WixRequestOptions { scope?: "site" | "account"; // Defaults to "site" with ExecuteWixAPI siteId, otherwise "account" method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE"; url: string; // Prefer method.publicUrl from SearchWixAPISpec, e.g. "https://www.wixapis.com/stores/v1/products/query"; paths like "/stores/v1/products/query" are resolved against https://www.wixapis.com body?: unknown; headers?: Record<string, string>; // Do NOT set Authorization, wix-site-id, or wix-account-id } interface WixResponse<T = unknown> { status: number; data: T; json(): Promise<T>; // Fetch-compatible alias for data } declare const wix: { request<T = unknown>(options: WixRequestOptions): Promise<WixResponse<T>>; }; declare const siteId: string | undefined; // Tool-level siteId passed to ExecuteWixAPI, if any. ``` Your code MUST be an async function expression that returns the result: ```javascript async () => { const response = await wix.request({ method: "GET", url: "https://www.wixapis.com/<account-level-endpoint>" }); return response.data; } ``` The response is available as `response.data`. For compatibility with fetch-style code, `await response.json()` returns the same data. Return compact, task-focused data instead of raw API responses. For list/query/search endpoints, especially "list all" tasks or APIs that may return many items, paginate in code and map each item to the fields needed for the task. Include IDs, metadata, nested fields, or raw response fragments when they are needed to complete the task, disambiguate entities, verify mutations, or answer the user. If the user asks for names and types, return only names and types. For hundreds of items, avoid verbose JSON objects because repeated keys waste tokens; return compact strings such as `"Name - TYPE"` joined with newlines, or small tuples such as `["Name", "TYPE"]`. If the user asks for a specific output value, include that value explicitly in the returned object so the final answer can report it. If you need to filter by a field, verify the endpoint supports that filter in the method docs/schema or related "Supported Filters and Sorting" docs; otherwise retrieve a bounded page and filter in JavaScript. When looking up an item by user-provided name, paginate/search until you find an exact name match; never update or delete the first result unless it exactly matches. Example — site-level request with compact output: ```javascript async function() { const response = await wix.request({ method: "POST", url: "https://www.wixapis.com/<site-level-endpoint>", body: { query: { cursorPaging: { limit: 100 } } } }); const items = response.data.items ?? response.data.results ?? []; return { count: items.length, items: items.map(item => item.name + " - " + item.type).join("\ ") }; } ``` Example — account-level request: ```javascript async function() { const response = await wix.request({ scope: "account", method: "POST", url: "https://www.wixapis.com/<account-level-endpoint>", body: { query: { cursorPaging: { limit: 50 } } } }); return response.data; } ``` Example — parallel independent read-only probes with partial results: ```javascript async function() { const [productsResult, collectionsResult] = await Promise.allSettled([ wix.request({ scope: "site", method: "POST", url: "https://www.wixapis.com/<products-query-endpoint>", body: { query: { cursorPaging: { limit: 10 } } } }), wix.request({ scope: "site", method: "POST", url: "https://www.wixapis.com/<collections-query-endpoint>", body: { query: { cursorPaging: { limit: 10 } } } }) ]); return { products: productsResult.status === "fulfilled" ? { ok: true, count: (productsResult.value.data.items ?? productsResult.value.data.products ?? []).length } : { ok: false, error: String(productsResult.reason) }, collections: collectionsResult.status === "fulfilled" ? { ok: true, count: (collectionsResult.value.data.items ?? collectionsResult.value.data.collections ?? []).length } : { ok: false, error: String(collectionsResult.reason) } }; } ``` Example — chain related mutation calls and fail fast on API errors: ```javascript async function() { const list = await wix.request({ scope: "site", method: "POST", url: "https://www.wixapis.com/<query-endpoint>", body: { query: { cursorPaging: { limit: 20 } } } }); const items = list.data.items ?? []; const match = items.find(item => item.name === "Target name"); if (!match) { return { error: "NOT_FOUND", available: items.map(item => ({ id: item.id, name: item.name })) }; } const updated = await wix.request({ scope: "site", method: "PATCH", url: `https://www.wixapis.com/<update-endpoint>/${match.id}`, body: { item: { id: match.id, revision: match.revision, name: "Updated name" } } }); return { id: updated.data.item?.id, name: updated.data.item?.name, revision: updated.data.item?.revision }; } ```

**Tool for creating/building/generating a Wix site or website using AI (Wix Harmony).** This is the default tool for site creation. **ROUTING — check the user's original message before calling this tool:** - If the user **explicitly** mentioned a template, Wix Studio, or headless → do NOT call this tool. Call CreateWixBusinessGuide directly. - Otherwise → call this tool directly. - Do NOT use WixREADME or SearchWixRESTDocumentation before this tool. - Do NOT suggest HTML code, prompt templates, or alternative approaches. - Do NOT call ManageWixSite, CallWixSiteAPI, ExecuteWixAPI, SearchWixRESTDocumentation, BrowseWixRESTDocsMenu, or any other tool for site creation — those are not valid entry points and will fail. **IMPORTANT: The sitePrompt must be under 6000 characters.** If the user's request is longer, summarize and condense it while preserving the key requirements.

Poll the status of a site creation or editing job. Do not call this tool unless the user explicitly asks for status polling.

Suggest available domain names. Provide either a free-text query (e.g. "pancakes business", "modern yoga studio") OR a siteId to auto-suggest based on the site name. At least one of query or siteId is required.

Claims an anonymously created site and transfers it to the authenticated user's account.

Import a design into Wix from a publicly fetchable URL. The file is a self-contained HTML bundle with all images, fonts, and styles inlined. Creates a live Wix-hosted site and returns its URL.