Execute JavaScript code against the Wix REST API.
Do not rely on memory for Wix API endpoints, methods, schemas, or request bodies. Before writing code, use the search, browse, read-docs, and schema tools to confirm the exact API URL, HTTP method, request body structure, schema field names, response shape, required fields, enum values, and auth context. Then write code using wix.siteRequest() or wix.accountRequest(). 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 site-level and account-level requests in one operation.
Use wix.siteRequest(siteId, opts) for site-level APIs, which is the common case for business domains such as Stores, Bookings, CRM, Forms, CMS, Events, and Blog. Use wix.accountRequest(opts) for account-level APIs such as Sites, Site Folders, Domains, and User Management, or when the docs/schema indicate account-level auth.
Available in your code:
```typescript
interface WixRequestOptions {
method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
url: string; // Full URL from schema, e.g. "https://www.wixapis.com/stores/v1/products/query"
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;
}
declare const wix: {
siteRequest<T = unknown>(siteId: string, options: WixRequestOptions): Promise<WixResponse<T>>;
accountRequest<T = unknown>(options: WixRequestOptions): Promise<WixResponse<T>>;
};
declare const siteId: string | undefined;
```
Your code MUST be an `async function()` expression that returns the result.
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.siteRequest(siteId, {
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.accountRequest({
method: "POST",
url: "https://www.wixapis.com/<account-level-endpoint>",
body: {
query: {
cursorPaging: { limit: 50 }
}
}
});
return response.data;
}
```
Example — chain related calls and branch on API responses:
```javascript
async function() {
const list = await wix.siteRequest(siteId, {
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.siteRequest(siteId, {
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
};
}
```