# [AI shopping agents: what they are and how they read your store](https://rebilder.com/learn/ai-shopping-agents)

> What AI shopping agents are, how ChatGPT, Claude, and Perplexity fetch and compare product pages, and how to see agent traffic on your own store.

- **Updated:** 2026-08-05
- **Author:** Rebilder
- **Published:** 2026-08-05

When `ChatGPT-User/1.0` appears in your server logs, a real customer just asked ChatGPT what to buy. That request came from an AI shopping agent: software shopping on behalf of a person with a budget. What your store answered decided whether you were recommended or skipped.

This guide covers what these agents are, how they fetch and read product pages, and why commerce is settling into a discover-in-chat, transact-on-site pattern. It ends with what to serve so an agent can extract price, availability, shipping, and returns without guessing.

## What is an AI shopping agent?

An AI shopping agent is software that shops on a buyer’s behalf. It takes an intent (“a 28-liter daypack under $150 with easy returns”), fetches product pages from stores, extracts the buying facts, compares the options, and reports back with a shortlist. The agents doing this today live inside the assistants people already use: ChatGPT, Claude, Perplexity, Gemini. From the customer’s seat the same thing is usually called an **AI shopping assistant**; from your server’s seat it is an HTTP client with distinctive headers and no patience for your theme.

Two properties separate an agent from every visitor you have optimized for so far. First, it does not render your page: no CSS, no hero image, no urgency badge, no reviews carousel. It reads text and markup. Second, it operates on a **context budget**: a model can only hold so many tokens of your page while comparing you against three competitors, so every byte of navigation and script crowds out a byte of product fact.

> **Agent ≠ crawler** A search crawler indexes your page for a query someone might make next month. A shopping agent is often acting on an intent that is seconds old, with a purchase decision at the end of the session. Both show up in your logs as bots; only one of them is holding a customer.

## How AI shopping agents browse your store

Agents announce themselves. Every entry below is taken from Rebilder’s corpus of real request-header samples (the fixtures our detection logic is tested against), not from vendor marketing:

| Agent | Identifies as | Asks for markdown? | What it means |
| --- | --- | --- | --- |
| ChatGPT (user browsing) | `ChatGPT-User/1.0` | No | A person asked ChatGPT something and it is fetching your page for them right now |
| OpenAI fetchers | `GPTBot/1.2`, `OAI-SearchBot/1.0` | No | Index building; what these collect feeds future answers |
| Perplexity | `PerplexityBot/1.0`, `Perplexity-User/1.0` | No | Answer-index crawling plus user-initiated fetches |
| Claude Code | `claude-code/2.0.13 (external, cli)` | Yes, via `Accept: text/markdown` | A terminal agent that explicitly requests text instead of markup |
| OpenCode | `opencode/0.5.29` | Yes, via `Accept: text/markdown` | Same pattern from another CLI agent: markdown-first fetching |

Notice the split. Terminal agents already send `Accept: text/markdown`, an explicit, standards-shaped request for a machine-readable format. Assistant fetchers like `ChatGPT-User` still ask for HTML, then burn tokens digesting it. Newer ChatGPT requests in the corpus also carry `Signature-Agent: "https://chatgpt.com"` with a cryptographic signature, the emerging Web Bot Auth pattern for proving which agent is calling. Rebilder’s gateway parses those headers and can verify the signature chain against a key registry you supply.

The browsing itself is brief. An agent fetches a handful of URLs, extracts what it can, and moves on. It does not scroll, click through your variant picker, or wait for hydration. Whatever facts are not cheaply reachable in the response body are either dropped from the comparison or guessed, and a guessed price is worse than a missing one.

## What an agent has to dig through today

We captured what a shopping agent receives from a typical Shopify-style product page, before and after content negotiation. The before is sobering: **91,226 bytes, roughly 22,789 tokens**, for one daypack. The first machine-readable price appears at character offset 23,185, buried in a `ProductJson` script blob, in cents. Stock status is an unlabeled `<span>`, and the backordered colorway is signaled only by a CSS class. Shipping and returns sit inside collapsed accordions, after eighteen reviews’ worth of widget markup.

The same request against the same store with a gateway installed returns **1,315 bytes, about 328 tokens**: a 98.6% reduction, roughly 69× less context for the same buying facts. And the facts get better, not worse, because they are front-loaded instead of scattered:

What the agent receives instead: first lines of the 1,315-byte response

```markdown
# [Alpine Trail Pack 28L](https://basecamp-supply.example/products/alpine-trail-pack-28l)

- **Brand:** Basecamp Supply Co
- **Price:** $148.00
- **Availability:** In stock
- **Shipping:** Free US shipping on orders over $75; standard shipping $6.95.
  - Free shipping threshold: $75.00
  - Ships to: US, CA
  - Delivery estimate: 3-6 days
- **Returns:** 60-day returns. Items must be unused with tags attached.
```

Price on line 4. Availability on line 5. Per-variant stock, shipping thresholds, and the returns window all inside the first screenful. An agent comparing four stores can now actually hold all four in context at once, and the store that answers this way is the easiest one to recommend accurately.

## Discover in chat, transact on site

Where does the purchase actually happen? The rails for agent-initiated checkout are real: ACP, the Agentic Commerce Protocol from OpenAI and Stripe, has been live since September 2025; UCP launched in January 2026 from Google and Shopify, with Etsy, Wayfair, Target, and Walmart backing it; MCP has become the data-connectivity layer agents use to talk to structured backends; and all three major card networks now support agent-initiated payments.

But the pattern that emerged is telling: OpenAI shifted from in-chat checkout to **discover in chat, transact on the merchant’s site**. The agent narrows the field and hands the buyer to you. That makes two things matter right now: whether your store is *readable* enough to make the agent’s shortlist, and what the handoff moment looks like when a pre-qualified buyer lands. The shortlist is decided in the agent’s context window, which is exactly where the token math above pays off.

> **Where Rebilder stands on protocols** The gateway serves UCP, ACP and MCP endpoints, and records every protocol probe (requests to paths like `/mcp` and `/.well-known/ucp`), so you can see the demand for protocol checkout arriving at your store whether or not you have wired the endpoints yet.

## What an AI shopping agent needs from your store

The durable answer is not a prettier page or a better prompt. It is a contract: for any product URL, serve the facts an agent needs (price, availability, per-variant stock, shipping terms, returns terms) from your **source of truth**, not scraped back out of your own theme. That is the whole design of Rebilder’s Agent Gateway, and the request lifecycle is short enough to state completely:

1. Classify the request as agent, human, search crawler, or protocol client, from signals like `Accept: text/markdown`, `Signature-Agent` headers, and the user-agent string.
2. Resolve the URL against your source of truth: product first, then policies, then catalog. No match means the request passes through to your normal site untouched.
3. Render markdown from injected fields only: the same price, stock, and policy text your HTML shows. Nothing is generated by a model, so nothing can drift or hallucinate.
4. Pass every human and every search crawler through to your canonical HTML. Googlebot always gets the real page, so there is no cloaking exposure.
5. Record the visit as an event: which agent, which URL, what was served, and how many milliseconds the render took.

The rule doing the heavy lifting is **same substance, different format**. The markdown is a transformation of the canonical page, never a different offer: same price, same availability, same policies. That single constraint is what keeps agent-readable serving compatible with search: there is nothing served to agents that a crawler would catch you hiding.

## Does agent traffic actually convert?

- **~38%**: AI-referred visitors convert higher than search visitors
- **~7x**: Sales growth for retailers with agent integration vs without
- **~4.2x**: Content negotiation vs llms.txt for accurate retrieval

The Cyber Week 2025 numbers are the clearest signal so far: retailers with agent integration saw roughly 7x the sales growth of those without, and AI-referred visitors converted about 38% higher than search visitors. The mechanism is not mysterious: a buyer arriving from an agent has already been qualified. The comparison happened in the chat. By the time they reach your product page, you have already won the shortlist.

One caveat about the popular fix. The mid-2026 study across 300k domains measured content negotiation (answering `Accept: text/markdown` with actual markdown) at about 4.2x more effective than llms.txt for accurate retrieval, and found that llms.txt alone shows **no citation lift**. Ship an llms.txt file; it is cheap and agents do fetch it. Just do not mistake it for the strategy. The strategy is answering the request the agent actually makes, on the URL it actually asks for.

## How to see agent traffic on your store today

You do not have to speculate about any of this: your own logs already contain the answer, and tooling for it is free. Rebilder’s Console gives you three live surfaces: a **side-by-side preview** that fetches any public URL of yours twice (once as an agent with `Accept: text/markdown`, once as a browser) and shows what each got, with approximate token counts; a **visit log** with one row per request, classified by kind and platform, showing what was served and how long the render took; and an **install page** with your store credentials and integration snippets. (One column worth pre-explaining: “Verified” tracks cryptographic agent signatures via Web Bot Auth. It reads “no” on almost every row, because most agent platforms have not started signing their requests yet; the column is measuring the industry, not your store.)

The [Agent Gateway](/docs/quickstart) itself is free, with adapters for Next.js, Shopify (via app proxy), Express, Fastify, and Cloudflare Workers, and it generates your [llms.txt](/docs/llms-txt) from the same source of truth. If you want to see the format before touching your stack, the [free llms.txt generator](/tools/llms-txt-generator) runs the same code in your browser.

## How do I know if AI shopping agents are visiting my website?

Search your server logs for the user-agent substrings real agents send: `ChatGPT-User`, `GPTBot`, `OAI-SearchBot`, `PerplexityBot`, `Perplexity-User`, `claude-code`, `opencode`. If you would rather have it classified per request, Rebilder’s free Console logs every visit with the agent kind and platform identified.

## What is the difference between an AI shopping agent and a web crawler?

A crawler indexes your pages for queries someone might make later; a shopping agent is usually acting on a live buying intent, with a person waiting on the answer. They also must be treated differently: search crawlers should always receive your canonical HTML (serving them something else is cloaking), while agents can be served the same substance as clean markdown.

## Do AI shopping agents actually buy things?

The payment rails exist: ACP (OpenAI + Stripe) has been live since September 2025, UCP (Google + Shopify) launched in January 2026, and the major card networks support agent-initiated payments. But the dominant pattern today is discover in chat, transact on the merchant’s site: the agent shortlists, the human completes the purchase with you. That is why being readable to agents matters before protocol checkout does.

## Should I block AI shopping agents from my store?

Separate the question by traffic type. Blocking training crawlers is a policy choice; blocking user-initiated agent fetches removes you from live purchase decisions. Cyber Week 2025 data showed AI-referred visitors converting about 38% higher than search visitors. That is demand, and blocking it hands the recommendation to a competitor who answered.

## How do I make my product pages readable to an AI shopping agent?

Answer the request agents actually make: content negotiation, meaning the same product URL returns clean markdown when asked with `Accept: text/markdown`. That approach measured about 4.2x more effective than llms.txt for accurate retrieval in the mid-2026 300k-domain study. Ship llms.txt as well (agents fetch it, and it costs nothing), but know that on its own it shows no citation lift. Rebilder’s free gateway does both from your source of truth.

## Related

- [AI search optimization: the definitive guide](https://rebilder.com/learn/ai-search-optimization)
- [Gateway quickstart: serve agents markdown in two lines](https://rebilder.com/docs/quickstart)
- [How request classification works](https://rebilder.com/docs/classification)
- [Console: the what-agents-see preview](https://rebilder.com/help/console/console-preview)
- [Which agents does Rebilder detect?](https://rebilder.com/help/agent-traffic/which-agents-detected)
- [Free llms.txt generator](https://rebilder.com/tools/llms-txt-generator)