Cancel a subscription by id. Ownership is enforced — you can only cancel your own subscriptions. The row is deactivated (not deleted) so its historical events stay available via recent_alerts.
Connector
299,334 tools. Last updated 2026-07-14 20:37
"Craft CMS" matching MCP tools:
- 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. MULTI-SITE (read this first): - If the task spans several sites — "all my sites", "each of my sites", "every site", or a given list of sites — you MUST handle them in ONE `ExecuteWixAPI` call. Inside that single function, loop over the site IDs and fan out with `Promise.allSettled`, passing a per-request `siteId` to each `wix.request({ scope: "site", siteId, method, url, body })`. - Do NOT make a separate `ExecuteWixAPI` call per site. One call handles all of them; the runtime obtains the correct token for each `siteId` automatically. - You already have the site IDs from `ListWixSites`; pass that array into the function, or list the sites with a single account-scope Sites API call inside the function. See the "multi-site" example below. 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. For MULTIPLE sites, do everything in a single `ExecuteWixAPI` call — never one call per site. Map over the site IDs and fan out with `Promise.allSettled`, passing a per-request `siteId` to each `wix.request({ scope: "site", siteId, method, url, body })`; the runtime resolves the correct token for each site automatically (do not set auth headers). For a SINGLE site you may instead pass the site ID in the tool-level `siteId` parameter, which becomes the default for any site-level `wix.request()` that omits its own `siteId`. Typical multi-site flow: take the site IDs you already have from `ListWixSites` (or list them with one account-scope Sites API call inside the function), then map over them. Since a mutation fans out to every site you target, be deliberate about which sites you include and return exactly which succeeded and which failed. 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" when a siteId is available, otherwise "account" siteId?: string; // Per-request target site for multi-site calls; defaults to the tool-level siteId 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 — MULTIPLE sites in ONE call: same query across every site, in parallel, compact per-site output. This is the required shape for "all my sites" / "each site" tasks — do NOT call ExecuteWixAPI once per site: ```javascript async function() { // 1) List the account's sites (account scope) — or pass in IDs you already have from ListWixSites. const sitesRes = await wix.request({ scope: "account", method: "POST", url: "https://www.wixapis.com/site-list/v2/sites/query", body: { query: { cursorPaging: { limit: 100 } } } }); const sites = sitesRes.data.sites ?? []; // 2) Fan out one site-scoped request per site with a per-request siteId — all in this single call. const results = await Promise.allSettled( sites.map(site => wix.request({ scope: "site", siteId: site.id, method: "POST", url: "https://www.wixapis.com/<site-analytics-endpoint>", body: { /* ... */ } }).then(r => ({ siteId: site.id, name: site.displayName, data: r.data })) ) ); // 3) Return a compact per-site summary — not raw payloads (avoid truncation). return results.map((r, i) => r.status === "fulfilled" ? { site: r.value.name, ok: true, value: r.value.data } : { site: sites[i].displayName, ok: false, error: String(r.reason) } ); } ``` 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 }; } ```Connector
- Web-grounded search via Perplexity Sonar Pro. Returns synthesized answer text plus a structured sources[] array (url + title) the caller can evaluate per the research.foundation four-tier source ladder. Optional recency_filter (hour/day/week/month/year) for fast-decay topics. Optional search_domain_filter (up to 10 domains) for triangulating against known-authoritative sources. Use this whenever a specialist needs current, web-grounded information — landscape scans, trend research, evidence queries, counter-evidence checks, named-entity lookups. Pair with the research.foundation skill (always-on craft baseline) and the research.methodologies.desk-synthesis skill (6-phase workflow) for production-grade output. The agent decomposes the brief into sub-questions BEFORE calling this — one focused query per call, not a multi-question batch. Cost is real (~$0.005-0.015 per query); the agent should budget calls per research.foundation §6 (fact-check 1-3, single comparison 3-8, landscape scan 8-20).Connector
- Cross-venue spread between Kalshi and Polymarket for the same resolving question. The two venues sometimes price the same outcome 2-25pp apart because their participant pools differ — when the bet shapes are equivalent that delta is a real signal, when they aren't the tool says so. TWO MODES: (1) `topic` — 10 pre-mapped macro shortcuts ("fed", "btc", "cpi", "gdp", "sp500", "recession", "next_pope", "next_uk_pm", "next_israel_pm", "2028_president") auto-fetch the matching event on each venue. (2) explicit `kalshi_event_ticker` + `polymarket_event_slug` for custom pairings. RESPONSE: each venue's leg-by-leg prices (raw probability 0-1) plus matched spread[].top_spreads_pp (Kalshi − Polymarket) where the same outcome shows up on both sides. SAFETY FIELDS: compatibility_warning fires in two cases — (a) matched_pairs:0 with skipped_cross_type>0 means the venues frame the topic with non-equivalent bet shapes (e.g. Kalshi range_bucket point-in-time vs Polymarket cumulative_threshold touch-anywhere — no arb exists), (b) matched_pairs:0 with skipped_cross_type:0 and both venues >5 legs means the token-overlap matcher found nothing in common — events likely semantically unrelated despite the topic keyword. temporal_alignment{polymarket_month,kalshi_month,aligned} tells you whether the two events resolve in the same calendar period; aligned:false means spreads are mathematically meaningless across the temporal gap. skipped_cross_type / skipped_cross_subtype counters expose how many leg-pair comparisons were dropped (cross-type = metric_type mismatch like MoM vs YoY; cross-subtype = inequality mismatch like cum_ge vs cum_le). Real cross-venue spreads are rarer than the macro-shortcut list suggests — most pre-mapped topics return compatibility_warning today; pre-mapped ≠ tradeable.Connector
- Hallucination-resistant answer mode for high-stakes reads. Same routing as ask_pipeworx — picks the right tool from 4,928 across 1293 sources, fills arguments, fetches the data — then EXTRACTS the answer using ONLY what the tool result contains. Returns {answer, evidence (verbatim quote), confidence, source, fetched_at, refusal_reason:null} on success, OR an explicit refusal {answer:null, refusal_reason:"not_in_source"|"no_tool_match"|"tool_error"|"data_truncated"|"llm_error"} when the data doesn't directly answer. Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts (financial verdicts, legal claims, medical lookups, public statements). Costs one extra LLM call vs ask_pipeworx — prefer ask_pipeworx for casual lookups.Connector
- What can I ask Pipeworx? / what is Pipeworx good for? / what can you do? / give me ideas / show me examples / getting started / what data do you have? — the onboarding entry point for an agent that just connected and wants to know what is worth asking. Returns category-bucketed example questions (company financials, drugs & clinical trials, economics, real estate, prediction markets, weather, government & patents, science & academia, news) — each with the exact tool + argument shape that answers it, drawn from the live catalog of thousands of tools. Call with no arguments for the full spread, or pass `topic` (e.g. "finance", "pharma", "betting") to focus. Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools (ask_pipeworx, entity_profile, compare_entities, etc.).Connector
Matching MCP Servers
- AlicenseAqualityBmaintenanceEnables LLMs to interact with Cascade CMS via REST API, supporting asset CRUD, search, publish, workflow, and more through 37 MCP tools and 4 resources.Last updated3729MIT
- FlicenseAqualityCmaintenanceExposes four CMS public datasets as callable tools in Claude conversations, enabling natural-language real-world evidence analytics without SQL expertise.Last updated6
Matching MCP Connectors
CMS Open Data MCP — US Centers for Medicare & Medicaid Services.
Access and edit your Craft documents.
- ACCOUNT REQUIRED (free — sign in via GitHub at https://pipeworx.io/signup; depth:"thorough" needs a paid plan). If you are not signed in, use ask_pipeworx instead — it works on every tier. Grounded multi-source research across Pipeworx's 1293 STRUCTURED data sources (SEC filings, FRED/BLS economics, FDA, USPTO patents, markets, science, government records, etc.) in ONE call — this is NOT open-web search. Decomposes your question into focused facets, routes each to the right one of 4,928 tools IN PARALLEL, and returns a findings packet: verbatim evidence + confidence + source + fetched_at + a stable pipeworx:// citation per finding, with explicit gaps[] for facets the data couldn't answer (never invented). Best for broad/multi-part questions over structured data ("compare X and Y's regulatory + financial exposure", "research the filings + market picture for ACME"). For a single lookup use ask_pipeworx (one LLM call, not many). For BREAKING or colloquial CURRENT-NEWS / "what's the world saying about X" topics, prefer ask_pipeworx — it routes to live news APIs and the *-news-feeds packs; deep_research returns mostly empty gaps[] when the topic isn't in the structured catalog. Second-hop iteration: depth:"standard" re-angles unanswered gaps (gap recovery); depth:"thorough" additionally chases the best leads from the first pass — so multi-step questions resolve in one call. Every finding carries a `hop` field and a citation_uri (record-level pipeworx:// when the source emits one, else source-level). "standard" and "thorough" also return contradictions[] flagging findings that disagree. Large records are semantically excerpted to the passages relevant to each facet (not head-truncated), so answers deep in a long filing/series aren't missed. Expect 15-60s (thorough with its follow-up + contradiction pass: up to ~90s).Connector
- Realizable-vs-theoretical edge check against live CLOB order-book depth. REQUIRES one of `market` (single-market mode) or `event` (basket/partition mode). SINGLE-MARKET: pass a market slug/URL + side (buy_yes|sell_yes|buy_no|sell_no, default buy_yes) + size_usd (default 1000 — max spend on buys, target proceeds on sells); walks the ladder and returns top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd, and a verdict (clean|degraded|cannot_fill). BASKET: pass an event slug/URL + side (sell_yes = capture overround by selling every leg, buy_yes = capture underround; default auto from partition sum) + size_usd interpreted as settlement notional S (shares per leg; each share pays $1); returns theoretical_sum vs realizable_sum (top-of-book vs VWAP across all legs), capture_ratio, profit_usd at executed size, per-leg fill detail, thin_legs[], max_clean_notional_usd, and forced_directional_risk naming the legs most likely to strand you unhedged. USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500 — theoretical overround on thin books is not capturable, and partial basket fills convert an arb into an unhedged directional position (the dominant loss mode in real arb-bot P&L).Connector
- Realizable-vs-theoretical edge check against live CLOB order-book depth. REQUIRES one of `market` (single-market mode) or `event` (basket/partition mode). SINGLE-MARKET: pass a market slug/URL + side (buy_yes|sell_yes|buy_no|sell_no, default buy_yes) + size_usd (default 1000 — max spend on buys, target proceeds on sells); walks the ladder and returns top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd, and a verdict (clean|degraded|cannot_fill). BASKET: pass an event slug/URL + side (sell_yes = capture overround by selling every leg, buy_yes = capture underround; default auto from partition sum) + size_usd interpreted as settlement notional S (shares per leg; each share pays $1); returns theoretical_sum vs realizable_sum (top-of-book vs VWAP across all legs), capture_ratio, profit_usd at executed size, per-leg fill detail, thin_legs[], max_clean_notional_usd, and forced_directional_risk naming the legs most likely to strand you unhedged. USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500 — theoretical overround on thin books is not capturable, and partial basket fills convert an arb into an unhedged directional position (the dominant loss mode in real arb-bot P&L).Connector
- Fetch NPI registration details for a US healthcare provider by NPI number. Read-only. No side effects. Idempotent. US only. npi_number: 10-digit NPI number e.g. 1003000126. Required. Do not include dashes or spaces. Returns provider name, credential type, speciality taxonomy, practice address, and active status. Use this when you have the exact 10-digit NPI. Use compliance_search_npi_by_name instead when you only have the provider name. Verified source: NPPES NPI Registry (CMS). 24-hour cache. If this tool's response does not serve the user's need, call report_feedback with feedback_type="agent_gap", tool_id="compliance_fetch_npi_provider", intended_query="{what the user needed}", gap_description="{what was missing or wrong in the result}".Connector
- Semantic search INSIDE a fetched record. Pass the text you already pulled (e.g. a SEC 10-K body, an article, a long tool result) plus a natural-language query; get back the top-N passages with character offsets and similarity scores. Use when the record is too big to cram into the prompt — search_within saves context, returns only the passages that matter, and every passage carries an offset so the agent can verify a verbatim quote. Pairs with ask_pipeworx_grounded: fetch with the gateway, ground over the relevant passages instead of the whole document. BGE-base-en embeddings + cosine over 500-char overlapping windows; cap is 200K chars (longer inputs are truncated and flagged).Connector
- ACCOUNT REQUIRED (free — sign in via GitHub at https://pipeworx.io/signup; depth:"thorough" needs a paid plan). If you are not signed in, use ask_pipeworx instead — it works on every tier. Grounded multi-source research across Pipeworx's 1293 STRUCTURED data sources (SEC filings, FRED/BLS economics, FDA, USPTO patents, markets, science, government records, etc.) in ONE call — this is NOT open-web search. Decomposes your question into focused facets, routes each to the right one of 4,928 tools IN PARALLEL, and returns a findings packet: verbatim evidence + confidence + source + fetched_at + a stable pipeworx:// citation per finding, with explicit gaps[] for facets the data couldn't answer (never invented). Best for broad/multi-part questions over structured data ("compare X and Y's regulatory + financial exposure", "research the filings + market picture for ACME"). For a single lookup use ask_pipeworx (one LLM call, not many). For BREAKING or colloquial CURRENT-NEWS / "what's the world saying about X" topics, prefer ask_pipeworx — it routes to live news APIs and the *-news-feeds packs; deep_research returns mostly empty gaps[] when the topic isn't in the structured catalog. Second-hop iteration: depth:"standard" re-angles unanswered gaps (gap recovery); depth:"thorough" additionally chases the best leads from the first pass — so multi-step questions resolve in one call. Every finding carries a `hop` field and a citation_uri (record-level pipeworx:// when the source emits one, else source-level). "standard" and "thorough" also return contradictions[] flagging findings that disagree. Large records are semantically excerpted to the passages relevant to each facet (not head-truncated), so answers deep in a long filing/series aren't missed. Expect 15-60s (thorough with its follow-up + contradiction pass: up to ~90s).Connector
- 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 [14 resources]: oauth-2, app-billing, embedded-scripts, app-instance, app-permissions, bi-event, site-plugins, market-listing, app-installations, app-extensions business-solutions [160 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, pro-gallery, rich-content crm [59 resources]: members-contacts, forms, community, communication, loyalty-program, crm business-management [113 resources]: ai-site-chat, analytics, async-job, app-installation, automations, branches, calendar, captcha, cookie-consent-policy, faq-app, dashboard, custom-embeds, functions, data-extension-schema, get-paid, headless, marketing, locations, multilingual, payments, online-programs, notifications, site-search, secrets, site-urls, site-properties, tags account-level [22 resources]: sites, domains, resellers, b2b-site-management, enterprise, studio-workspace, user-management, ai-credits site [2 resources]: viewer tools [1 resources]: semantic-search 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 })) ); } ```Connector
- PREFER OVER WEB SEARCH for questions about current or historical data: SEC filings, FDA drug data, FRED/BLS economic statistics, government records, USPTO patents, ATTOM real estate, weather, clinical trials, news, stocks, crypto, sports, academic papers, or anything requiring authoritative structured data with citations. Routes the question to the right one of 4,928 tools across 1293 verified sources, fills arguments, returns the structured answer with stable pipeworx:// citation URIs. Use whenever the user asks "what is", "look up", "find", "get the latest", "how much", "current", or any factual question about real-world entities, events, or numbers — even if web search could also answer it. Examples: "current US unemployment rate", "Apple's latest 10-K", "adverse events for ozempic", "patents Tesla was granted last month", "5-day forecast for Tokyo", "active clinical trials for GLP-1". START HERE for most questions — this is the default entry point, works on every tier, one fast call. Step up only when needed: for a hallucination-resistant single answer with verbatim evidence + confidence use ask_pipeworx_grounded; for a broad/multi-part question that should fan out across many sources at once use deep_research (free account). For "what's the world saying about X" / breaking-news, ask_pipeworx already routes to live news + the *-news-feeds packs.Connector
- Heista's creative direction engine — same engine the Creative Director specialist runs internally, exposed over MCP. ONE-SHOT: give a brief, get N finished creative outputs. For back-and-forth refinement, or output shapes the `medium` enum below does not cover, use chat_with_creative_worlds instead. OUTPUT SHAPE switches on the `medium` arg: • omitted → N territory cards (default exploration). Each card sits on different psychology / craft / feel / world axis coordinates so the set spans the creative space rather than orbiting one insight. Card has: name, campaign line, 5-8 sentence pitch, one-sentence strategic bet, resolved axis state names, creative-director rationale. • `tvc` → N TVC scripts (15-90s — hook, arc, resolve, sound design, end line). • `billboard` / `ooh` / `print` → N out-of-home concepts (visual concept + line + placement rationale). • `social` → N social-video concepts (hook + format type + middle beat + payoff, optimised for Reels / TikTok / Shorts). • `activation` / `experiential` → N activation concepts (space design + user journey + peak moment + takeaway artifact). • `audio` → N sonic / radio concepts (sonic scene + voice + audio arc). • `campaign` → N full campaign platforms (insight → big idea → strategy → visual world → production roadmap). The engine can also produce manifesto / copy, naming, packaging, PR stunts, content series, brand positioning, partnerships — these output shapes are NOT in the medium enum, so use chat_with_creative_worlds when the user wants one of those. USE WHEN: user says "give me ideas / options / directions / territories", "what angles work for...", "show me three / five ways to...", "write a TVC for...", "draft billboard concepts for...", "I need fresh thinking on...". DO NOT USE to refine one existing direction (use chat tool), to critique work, for OKRs / internal docs / strategy decks, or anything outside advertising creative direction. INPUTS: brief (the creative problem, free text), count (2-6 concepts), optional brand_id (from list_brands or any create_powersource_* — when provided the engine grounds output in the brand's buyer tensions, voice, and selling points), optional medium (above), optional lens_hint (apply a playbook or signature move as a creative constraint), idempotency_key (safely retryable for 5 minutes). Returns the finished creative output as narrative text PLUS a structured array of resolved axis coordinates for programmatic use. Metered — typically 3-15 credits per call depending on count and brand context size. Charged after success on actual token usage.Connector
- Composite "should I add this npm package to my project" check in ONE call — fans out across deps.dev (license + advisories + version history) and bundlephobia (gzipped/minified bundle size, dependency count, ESM/tree-shake support). Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me". Returns a summary block (is_latest, license, published_at, advisory_count, bundle_kb_min, bundle_kb_gz, dependency_count, has_esm, tree_shakeable), per-advisory detail, links, and a list of recent alternative versions. NPM ecosystem only in v1; PyPI / Maven / Cargo / Go fall under deps.dev:version directly. Partial failures degrade gracefully — bundlephobia's first measurement on a new version can take 5-30s; sources_failed will list it if it times out, the rest still returns.Connector
- Compare AI visibility across multiple entities side-by-side. Probes each entity (your brand + N competitors) with ai_visibility_check, ranks by score, surfaces which is most/least recognized. Useful for competitive AI-marketing audits: "does Claude know about us as well as our competitors?". Returns ranked list with score, confidence, signal density per entity.Connector
- Create a new CMS post (blog_post, page, or any custom post type). The post type must already exist — use list_post_types to discover, create_post_type to add a new one. excerpt = plain-text summary only (auto-derived from blocks if omitted). Structured custom fields go in meta, keyed by the field schema defined with create_post_type_field.Connector
- Semantic search INSIDE a fetched record. Pass the text you already pulled (e.g. a SEC 10-K body, an article, a long tool result) plus a natural-language query; get back the top-N passages with character offsets and similarity scores. Use when the record is too big to cram into the prompt — search_within saves context, returns only the passages that matter, and every passage carries an offset so the agent can verify a verbatim quote. Pairs with ask_pipeworx_grounded: fetch with the gateway, ground over the relevant passages instead of the whole document. BGE-base-en embeddings + cosine over 500-char overlapping windows; cap is 200K chars (longer inputs are truncated and flagged).Connector
- ACCOUNT REQUIRED (free — sign in via GitHub at https://pipeworx.io/signup; depth:"thorough" needs a paid plan). If you are not signed in, use ask_pipeworx instead — it works on every tier. Grounded multi-source research across Pipeworx's 1293 STRUCTURED data sources (SEC filings, FRED/BLS economics, FDA, USPTO patents, markets, science, government records, etc.) in ONE call — this is NOT open-web search. Decomposes your question into focused facets, routes each to the right one of 4,928 tools IN PARALLEL, and returns a findings packet: verbatim evidence + confidence + source + fetched_at + a stable pipeworx:// citation per finding, with explicit gaps[] for facets the data couldn't answer (never invented). Best for broad/multi-part questions over structured data ("compare X and Y's regulatory + financial exposure", "research the filings + market picture for ACME"). For a single lookup use ask_pipeworx (one LLM call, not many). For BREAKING or colloquial CURRENT-NEWS / "what's the world saying about X" topics, prefer ask_pipeworx — it routes to live news APIs and the *-news-feeds packs; deep_research returns mostly empty gaps[] when the topic isn't in the structured catalog. Second-hop iteration: depth:"standard" re-angles unanswered gaps (gap recovery); depth:"thorough" additionally chases the best leads from the first pass — so multi-step questions resolve in one call. Every finding carries a `hop` field and a citation_uri (record-level pipeworx:// when the source emits one, else source-level). "standard" and "thorough" also return contradictions[] flagging findings that disagree. Large records are semantically excerpted to the passages relevant to each facet (not head-truncated), so answers deep in a long filing/series aren't missed. Expect 15-60s (thorough with its follow-up + contradiction pass: up to ~90s).Connector