ChatGPT site tools: a readiness checklist

Updated
Reading time
7 min
Sources
7 linked
For AI tools
Markdown version

Short answer

ChatGPT’s desktop app can call Site tools on pages it visits. Shopify defaults still often miss answering “Where’s my order?” and starting returns in-chat. Use this checklist to register tools correctly; run the free product data check to see what your store already exposes for AI shoppers, ChatGPT shopping and BFCM. Prefer the shape first? See a sample report. BFCM season (Black Friday 2026 is Nov 27): October is scan month — pair this checklist with the BFCM checklist for AI shoppers and a free scan; desktop Site tools still have honest limits.

Since August 25, 2026, ChatGPT’s desktop app can surface Site tools while a shopper (or agent) is on your store — so “Where’s my order?” and returns stop being dead ends if your tools are registered correctly. Shopify’s defaults still often miss those post-purchase answers; that gap matters more as BFCM volume rises. Under the hood, those tools are registered with WebMCP on the page. Browse other guides, see how it works, or the free ladder on pricing.

Free product data check for ChatGPT, AI shoppers and BFCM · See the shape first: See a sample report (EXAMPLE)

If you want us to implement fixes after your report, ask — builds stay paid only when you ask.

Who can use Site tools

ChatGPT Site tools require the desktop app. They work only with GPT-5.6 Sol and Terra as of August 25, 2026. GPT-5.6 Luna has WebMCP disabled. Enterprise and Edu accounts do not have access.

Safari and Firefox do not support WebMCP. Chrome 149–156 supports it via an origin trial. Chrome 157, targeted for around November 3, 2026, is the expected default-on release: that date has not been committed.

Registration checklist

Use the right entry point

  • Register tools with document.modelContext.registerTool(), not navigator.modelContext. The navigator.modelContext entry point is deprecated and being removed in Chrome 150–152.
  • Do not call provideContext(), which was removed in March 2026.
  • Do not call unregisterTool(), which was removed in April 2026. Use an AbortSignal to unregister.
  • Wrap registration in a feature check (if (!('modelContext' in document)) return; inside your setup function) so the code does nothing on browsers without WebMCP.

Register on the top-level page, early

  • Register tools in JavaScript on the top-level page, not inside an iframe. ChatGPT's agent reads only tools registered on the top-level document.
  • Don't rely on HTML form attributes alone. Chrome reads them, but ChatGPT's agent does not.
  • Register tools as early as you can after page load, and check that they appear in the WebMCP panel in Chrome DevTools. Do not wait for heavy application bundles, third-party scripts, or consent popups to resolve before registering.
  • If you show a cookie consent banner or modal that blocks the page, ensure it does not delay tool registration or prevent the agent from reading the tool list.

Name and describe tools clearly

  • Keep tool names short, specific, and lowercase with underscores or hyphens: get_order_status, not getOrderStatusForCurrentUser_v2.
  • Tool names must be 1–128 characters, ASCII alphanumeric, underscores (_), hyphens (-), or periods (.) only.
  • Write descriptions that answer: what does this tool do, when should the agent use it, what does it require? One or two short sentences is usually enough. Avoid padding.
  • Do not write descriptions so long that the agent spends tokens parsing them. Keep them succinct, in line with Chrome's WebMCP guidance.

Write tight input schemas

  • Use JSON Schema with a type: "object" wrapper.
  • List every required field in the required array. Do not leave fields optional that the tool needs to run.
  • Use enum for fields with a fixed set of valid values (reasons, statuses, categories). Enums help the agent pick a valid value instead of guessing.
  • Add a short description to each property explaining what value belongs there and in what format.

Set annotations

Browsers don't enforce annotations, but they tell agents how careful to be. ChatGPT shows whether a site tool reads data or makes changes, and asks the user to confirm actions such as purchases, deleting data, sending messages or sharing personal information.

  • Set readOnlyHint: true on lookup tools (order status, product lookups, FAQ answers). Signals that the tool changes nothing.
  • Set consequentialHint: true on tools that change state: submitting a return, sending a message, anything the shopper cannot undo easily.
  • Set untrustedContentHint: true on tools whose output includes user-generated content (reviews, support text) to flag prompt-injection risk.

Handle results and errors

  • Return concise JSON or plain text. The agent passes your result to a language model. A 10 KB blob costs tokens; a focused result costs less and signals more clearly.
  • Return a clear error message when the tool cannot complete its task: { "error": "Order not found or you are not logged in." } is more useful to the agent than an HTTP 500 or a silent empty result.
  • Do not throw unhandled exceptions from execute(). Return a structured error instead.

Respect the AbortSignal

  • Pass a signal from an AbortController to registerTool(). This is how you unregister a tool when a single-page app changes route or a component unmounts.
  • Check signal.aborted at the start of execute() for long-running operations, and exit cleanly if the signal has fired.

Code example

Two tools: one read-only lookup, one consequential action. Both registered with a shared AbortController so they unregister together on cleanup.

if (!document.modelContext) {
  // WebMCP not available: fail silently
} else {
  const controller = new AbortController();
  const { signal } = controller;

  // Read-only lookup: safe to retry, no side effects
  document.modelContext.registerTool(
    {
      name: "get_order_status",
      title: "Get order status",
      description:
        "Returns carrier, tracking number, and estimated delivery for an order. " +
        "Customer must be logged in. Use the order number from the confirmation email, e.g. #1042.",
      inputSchema: {
        type: "object",
        properties: {
          order_number: { type: "string", description: "Order number, e.g. #1042" }
        },
        required: ["order_number"]
      },
      // Your own endpoint; Shopify has no order-status tool by default.
      async execute({ order_number }, { signal }) {
        if (signal.aborted) return { error: "Cancelled." };
        const res = await fetch(
          `/tools/order-status?order=${encodeURIComponent(order_number)}`,
          { signal }
        );
        if (!res.ok) return { error: "Order not found or not logged in." };
        return res.json();
      },
      annotations: { readOnlyHint: true }
    },
    { signal }
  ).catch((e) => console.warn("get_order_status not registered:", e));

  // Consequential action: confirm with the customer before calling
  document.modelContext.registerTool(
    {
      name: "submit_return_request",
      title: "Submit return request",
      description:
        "Opens a return for one line item. Irreversible once submitted. " +
        "Confirm order number, item, and reason before calling.",
      inputSchema: {
        type: "object",
        properties: {
          order_number: { type: "string", description: "Order number, e.g. #1042" },
          line_item_id: { type: "string", description: "Line item ID from the order" },
          reason: {
            type: "string",
            enum: ["wrong_size", "defective", "not_as_described", "changed_mind"]
          }
        },
        required: ["order_number", "line_item_id", "reason"]
      },
      async execute({ order_number, line_item_id, reason }, { signal }) {
        if (signal.aborted) return { error: "Cancelled." };
        const res = await fetch("/tools/returns", {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          signal,
          body: JSON.stringify({ order_number, line_item_id, reason })
        });
        if (!res.ok) return { error: "Return could not be started. Check eligibility." };
        return res.json();
      },
      annotations: { consequentialHint: true }
    },
    { signal }
  ).catch((e) => console.warn("submit_return_request not registered:", e));

  // Unregister both tools on teardown: controller.abort();
}

registerTool() returns a Promise that rejects if, for example, the name is already taken. Await it or attach .catch(), as above, so registration errors show up in your console.

Testing checklist

  • Chrome flag. Open chrome://flags in Chrome 146 or later and enable #enable-webmcp-testing. Install the "Model Context Tool Inspector" extension. Visit your store page. Confirm all expected tools appear in the inspector with correct names and schemas.
  • ChatGPT desktop. Open the ChatGPT desktop app. Switch to GPT-5.6 Sol or Terra. Visit your store in the built-in browser. Check the address bar for the Site tools arrow. Ask the agent to use a tool by name and verify the result.
  • Timing. Open your browser's DevTools and record how long after page load each tool registers. If any tool registers after 3 seconds, move the registration earlier or load it independently of slower scripts.
  • Popup and overlay test. Check whether any modal, banner, or overlay appears within the first 3 seconds that would prevent an agent from reading the page. Cookie banners are the most common blocker.
  • Error paths. Test each tool with missing required fields, invalid values, and a logged-out session. Verify that error messages are descriptive, not generic.
  • AbortSignal. Navigate away mid-request and confirm the tools unregister without throwing.

What to expect from Site tools now

Agent-placed orders remain essentially zero in real stores as of September 2026. One store owner reported none after adding WebMCP tooling to a live eSIM store (Indie Hackers, September 2, 2026). The practical value of custom tools is fewer support tickets, shoppers getting a direct answer to "where is my order?", not automated purchases. Build for that outcome first.

Questions people ask (and honest answers)

Does ChatGPT Site tools work in Chrome/Safari on the open web?
Site tools are read in ChatGPT’s desktop app browser (as of August 25, 2026 on this page). Don’t expect full Chrome/Safari Site tools for shoppers on the open web yet.

Do Shopify’s default tools answer “Where’s my order?”
Defaults often only send people to order history or login. A custom track-order style tool—and a free scan of your pages—is how you check the gap.

Will this get me more AI orders before Black Friday?
We don’t promise agent revenue. Aim for readiness and fewer support tickets; a free product data check shows what’s missing before BFCM. October is scan month — don’t wait until early November if you still need builds.

Is the next step paid?
No — send your store URL and we email free AI-readiness findings plus a free how-to-fix report. Builds only if you ask us to implement.

Get a free scan

Know what ChatGPT shopping and other AI shoppers already see on your storefront — before peak week.

Before Black Friday, also use the BFCM checklist for AI shoppers — October for the free findings + free how-to-fix report; implement only if you ask.

→ Free product data check for ChatGPT, AI shoppers and BFCM
→ See the report shape first: See a sample report (EXAMPLE)

If you want us to implement the fixes after your report, ask — builds stay paid only when you ask.

Sources

  1. Search Engine Journal: ChatGPT Adds WebMCP Support For Interactive Websites
  2. tech-tech.life: WebMCP: the why, the what, and the how
  3. WebMCP specification (W3C Web Machine Learning Community Group)
  4. IMMACULATE: WebMCP Is Live on Every Liquid Storefront
  5. Chrome for Developers: WebMCP tool security
  6. Chrome for Developers: Debug WebMCP tools
  7. Indie Hackers: Added WebMCP to my live eSIM store
Next guideWebMCP vs MCP: what is the difference and when do you need each?

Free product data check for ChatGPT, AI shoppers and BFCMSee a sample report (EXAMPLE)

Get a free scan.

Black Friday starts November 27. Free scan — what AI shopping assistants can do on your store, what's missing, and three tools with suggested code. We email your free report.

If you want us to implement the fixes after your report, ask — builds stay paid only when you ask.

Free report by email. No login. No admin access.

See a sample report (EXAMPLE)

YOUR STORE · PRODUCT DATA CHECK · FREE