# How to make your online store visible to ChatGPT and AI shopping assistants

2026-10-25

Shoppers have started asking ChatGPT, Perplexity, Claude and Google's AI Mode the questions they used to type into a search box: *"best trail running shoes under €100"*, *"which espresso machine is easiest to clean"*, *"where can I buy this in stock today"*. The answer is a short list of products with prices and links - and a store that the assistant could not read is simply not on it.

Being on that list starts with plain, checkable technical work: letting the right crawlers in, describing products in a way a machine can parse, and serving pages that make sense without JavaScript. This guide walks through all of it, in the order that matters most, with code you can copy. To see where your store stands first, run the [free AI readiness check](https://grandnode.com/ai-readiness) - it tests all 27 points below and needs nothing but your store's address.

### The short version

- **Let AI assistants in, separately from AI training.** OpenAI, Anthropic and Perplexity use different crawlers for answering customers and for training models. You can block training and still be recommended.
- **Publish complete product data as JSON-LD:** price with currency, availability, brand, an identifier (GTIN, MPN or SKU), shipping and returns.
- **Make the HTML stand on its own.** Most AI crawlers do not run JavaScript; a price that appears only after a script runs may never be seen.
- **Keep the basics clean:** a sitemap with product URLs and dates, indexable product pages, HTTPS, fast responses.
- **Add an llms.txt file** if you like - it is cheap, but it is the least important item on this list.

### Check your store in ten seconds

We built the [AI readiness checker](https://grandnode.com/ai-readiness) to answer one question from the outside, the way an AI crawler would: *can an assistant find, read and trust this store?* Enter your store's address - or better, the address of one product page - and it reads a handful of public resources: robots.txt, the home page, llms.txt, the sitemap and one product page.

![The GrandNode AI readiness checker: a field for the store's address and a Check my store button](https://grandnode.com/assets/images/uploaded/ai-readiness-check-form.webp)

You get a score from 0 to 100, a grade (*Ready for AI shoppers*, *Getting there* or *Not ready yet*) and 27 results, each with a status, the points it earned and a sentence on why it matters. The check is free, needs no sign-up and works for any platform - Shopify, WooCommerce, Magento, PrestaShop, GrandNode or your own code. If you want the list with fix-it hints in your inbox, you can ask for an e-mailed report.

It is also a well-behaved crawler, because a tool about crawler etiquette should be: at most 8 small GET requests per check, no JavaScript executed, no forms submitted, the same site fetched at most once every 10 minutes, and robots.txt obeyed for its own token, `GrandNode-AI-Readiness`.

### What the score is made of

The 27 checks fall into seven areas. The weights reflect what most affects whether an assistant can recommend a product: structured product data and crawler access carry more than half of the score.

| Area | Points | What it answers |
|---|---|---|
| Product data for machines | 35 | Can an assistant read the product, its price, stock, brand, shipping and returns without guessing? |
| AI crawler access | 19 | Does robots.txt let AI search and shopping agents in? |
| Discoverability | 14 | Is there a sitemap with product URLs and dates, and can product pages be indexed? |
| HTTPS and security headers | 11 | Is the store served securely? |
| llms.txt | 10 | Is there a short guide to the store written for language models? |
| Speed basics | 6 | Does the server answer quickly, with compact, compressed HTML? |
| Readable without JavaScript | 5 | Are the title, description, product name and price in the HTML as served? |

Two rules keep the score fair. First, anything the checker could not measure - a page your robots.txt asked it not to read, a product page it could not find - is marked *Not checked* and left out of the calculation instead of counting as a failure. Second, blocking AI *training* crawlers never costs points. That is a legitimate business decision, and it has nothing to do with whether assistants can recommend you.

### 1\. Product data that machines can read (35 points)

An assistant comparing three espresso machines needs the same facts for each: what it is, what it costs and in which currency, whether it is in stock, who makes it, what delivery costs and whether it can be returned. A human reads that from the page layout. A machine reads it reliably only from structured data - [schema.org](https://schema.org/Product) JSON-LD in the page's HTML.

![AI readiness check results for product data: store identity, product structured data, price and currency, availability, identifiers, link previews, ratings, shipping and returns](https://grandnode.com/assets/images/uploaded/ai-readiness-check-product-data.webp)

The checker looks for eight things:

| Check | Points | Passes when |
|---|---|---|
| Store identity | 4 | The home page has `Organization`, `OnlineStore` or `WebSite` JSON-LD. |
| Product structured data | 10 | The product page has a JSON-LD `Product` (microdata alone earns half). |
| Price and currency | 6 | The offer has a `price` *and* a `priceCurrency`. |
| Availability | 4 | The offer states `availability`. |
| Image, brand, identifier | 4 | `image`, `brand` and one of `gtin`, `mpn` or `sku`. |
| Link preview tags | 2 | `og:title` and `og:image` on the product page. |
| Ratings | 2 | `aggregateRating` or `review` in the JSON-LD. |
| Shipping and returns | 3 | `shippingDetails` and `hasMerchantReturnPolicy` on the offer, product or organization. |

A product block that passes all of them looks like this. It goes inside a `<script type="application/ld+json">` tag on the product page:

```
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Northpeak X1 trail running shoe",
  "image": "https://shop.example/images/x1-black.jpg",
  "sku": "X1-42-BLK",
  "gtin13": "5901234123457",
  "brand": { "@type": "Brand", "name": "Northpeak" },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "128"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://shop.example/northpeak-x1",
    "price": "89.00",
    "priceCurrency": "EUR",
    "availability": "https://schema.org/InStock",
    "shippingDetails": {
      "@type": "OfferShippingDetails",
      "shippingRate": { "@type": "MonetaryAmount", "value": "4.90", "currency": "EUR" },
      "shippingDestination": { "@type": "DefinedRegion", "addressCountry": "DE" }
    },
    "hasMerchantReturnPolicy": {
      "@type": "MerchantReturnPolicy",
      "applicableCountry": "DE",
      "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
      "merchantReturnDays": 30
    }
  }
}
```

Three details trip up most stores:

- **A price without a currency.** `"price": "89.00"` alone cannot be compared with anything. Always add `priceCurrency`.
- **Ratings visible only to people.** Stars drawn by a review widget after the page loads are invisible to a crawler. If you have reviews, publish them as `aggregateRating`.
- **Data that disagrees with the page.** Google's guidance for its AI features asks that [structured data matches the visible text](https://developers.google.com/search/docs/appearance/ai-features). A JSON-LD price that differs from the displayed one undermines trust in both.

Google also says there is no special markup you must add to appear in its AI features. That is true, and it is not a reason to skip JSON-LD: the same data powers product rich results and merchant listings, and it is the least ambiguous way for every other assistant to read your offer. In GrandNode, product JSON-LD with price, availability, rating, shipping and returns is built in - see [Structured data (JSON-LD)](https://grandnode.com/seo-structured-data) for how to make it complete.

### 2\. Let AI assistants in - and decide about training separately (19 points)

This is where well-meaning stores lose the most. After the first wave of AI training crawlers, many shops - or their hosting and CDN providers - blocked "AI bots" wholesale. The catch: the big AI companies run *separate* crawlers for training models and for answering a customer's question. Block the second kind and the assistant cannot read your product when someone asks about it.

| Company | Answering customers (search and shopping) | Training models |
|---|---|---|
| OpenAI | `OAI-SearchBot`, `ChatGPT-User` | `GPTBot` |
| Anthropic | `Claude-SearchBot`, `Claude-User` | `ClaudeBot` |
| Perplexity | `PerplexityBot`, `Perplexity-User` | \- |
| Google | `Googlebot` (AI Overviews and AI Mode use the Search index) | `Google-Extended` |
| Apple | `Applebot` | `Applebot-Extended` |
| Common Crawl | \- | `CCBot` |

The vendors are explicit about it. OpenAI states that sites opted out of `OAI-SearchBot` are not shown in ChatGPT search answers, while `GPTBot` controls training only ([OpenAI crawlers](https://developers.openai.com/api/docs/bots)). Anthropic says blocking `Claude-SearchBot` or `Claude-User` may reduce your visibility in user-directed search ([Anthropic crawlers](https://support.claude.com/en/articles/8896518-does-anthropic-crawl-data-from-the-web)). Perplexity asks you to allow `PerplexityBot` if you want to appear in its results ([Perplexity crawlers](https://docs.perplexity.ai/docs/resources/perplexity-crawlers)). Google says `Google-Extended` does not affect inclusion in Search.

![AI readiness check results for AI crawler access: robots.txt is readable, AI assistants can reach your pages, an explicit AI crawler policy](https://grandnode.com/assets/images/uploaded/ai-readiness-check-ai-crawlers.webp)

The checker scores three things here: whether robots.txt can be read at all (3 points), what share of the six assistant crawlers above may fetch both your home page and a product page (10 points), and whether robots.txt names any AI crawler explicitly (6 points) - which shows a deliberate policy, whichever way you decided. A robots.txt that allows assistants and opts out of training looks like this:

```
# AI search and shopping assistants: welcome
User-agent: OAI-SearchBot
User-agent: ChatGPT-User
User-agent: Claude-SearchBot
User-agent: Claude-User
User-agent: PerplexityBot
User-agent: Perplexity-User
Disallow: /cart
Disallow: /checkout
Disallow: /account

# AI model training: your call - this store opts out
User-agent: GPTBot
User-agent: ClaudeBot
User-agent: Google-Extended
User-agent: Applebot-Extended
User-agent: CCBot
Disallow: /

# Everyone else
User-agent: *
Disallow: /cart
Disallow: /checkout
Disallow: /account
Sitemap: https://shop.example/sitemap.xml
```

Note the repeated `Disallow` lines. Under the robots.txt standard (RFC 9309), a crawler obeys only the most specific group that names it. Once you give `OAI-SearchBot` its own group, the rules under `User-agent: *` no longer apply to it - so copy the paths you want kept private into the assistants' group too.

Two more things to know:

- **Your CDN may be deciding for you.** Cloudflare and other providers offer one-click AI bot blocking and managed robots.txt rules. If the checker finds a Cloudflare-managed block while assistants are locked out, it tells you - the fix is in the CDN dashboard, not in your store.
- **User-triggered fetchers may ignore robots.txt.** OpenAI notes that robots.txt rules may not apply to `ChatGPT-User`, and Perplexity says `Perplexity-User` generally ignores it, because a person asked for the page. robots.txt is a signal of intent, not access control - anything truly private belongs behind a login.

GrandNode lets you edit robots.txt per store, including rules for AI crawlers - see [Sitemap and robots.txt](https://grandnode.com/seo-sitemap-and-robots).

### 3\. Discoverability: sitemap and indexable product pages (14 points)

AI search engines build their indexes much like classic search engines, and they start from the same places. The checker looks for a valid sitemap (6 points), product URLs in it with `<lastmod>` dates on at least half of the entries (4 points), and a product page that can be indexed (4 points): no `noindex` in the robots meta tag or `X-Robots-Tag` header, no `nosnippet`, and a canonical URL on your own site.

Two easy wins: point to your sitemap from robots.txt, and submit it in both Google Search Console and Bing Webmaster Tools - Microsoft Copilot answers from Bing's index.

### 4\. HTTPS and security headers (11 points)

Assistants, like browsers and payment providers, prefer stores they can trust. The checker gives 5 points for HTTPS with a valid certificate, 1 for redirecting `http://` to `https://`, 2 for `Strict-Transport-Security` with a `max-age` of at least 180 days, and 1 point each for `X-Content-Type-Options: nosniff`, clickjacking protection (`X-Frame-Options` or CSP `frame-ancestors`) and a `Content-Security-Policy` header. None of this is new; it is simply the baseline any shopper - human or machine - should expect.

### 5\. llms.txt: useful, cheap, and not magic (10 points)

[llms.txt](https://llmstxt.org/) is a proposed standard: a short Markdown file at `/llms.txt` that tells language models what a site is and where its key pages live. For a store it might look like this:

```
# Northpeak Outdoor
> Trail running and hiking gear. Ships across the EU in 2-4 days, 30-day free returns.

## Shop
- [Trail running shoes](https://shop.example/trail-running-shoes): road-to-trail and mountain models
- [Hiking backpacks](https://shop.example/hiking-backpacks): 20-60 litres

## Help
- [Shipping and returns](https://shop.example/shipping-returns)
- [Size guide](https://shop.example/size-guide)
```

To be straight about it: Google says you do not need AI-specific text files to appear in its AI features, and studies of AI-cited pages have found little sign that llms.txt changes who gets cited today. It is read by some AI agents and coding tools, it takes ten minutes to write, and it forces you to state clearly what your store sells - which is why it is worth 10 points here, and why it comes after everything above. The checker gives 7 points for a valid file (served as text, starting with a `# ` heading) and 3 for links to your own store in it.

### 6\. Readable without JavaScript (5 points)

Most AI crawlers fetch your HTML and read it as served - they do not run your JavaScript. If your product name and price are rendered in the browser by a front-end framework, the crawler may see an empty template. The checker reads the raw HTML: the home page needs a `<title>`, a meta description and at least 500 characters of visible text (2 points); the product page needs the product's name and price in its visible text (3 points). Server-side rendering, or pre-rendering for product and category pages, solves it.

### 7\. Speed basics (6 points)

Crawlers work within time budgets; a slow page gets read less often, and a huge one may be cut off. Measured on the home page: server response time (full points up to 600 ms, none from 2 seconds), HTML size (full points up to 100 KB, none from 1 MB) and compression with Brotli or gzip.

### We ran the check on our own site

A checker is only credible if its authors use it on themselves. Here is grandnode.com - a GrandNode store selling software add-ons - checked on one of its product pages:

![AI readiness check of grandnode.com: score 90, Ready for AI shoppers, platform detected GrandNode](https://grandnode.com/assets/images/uploaded/ai-readiness-check-score.webp)

**90 out of 100, *Ready for AI shoppers*.** Crawler access, llms.txt, sitemap, indexability, HTML, HTTPS headers and speed all passed. Three things did not:

- **No explicit AI crawler policy (0 of 6).** Our robots.txt allows every crawler, so assistants can reach everything - but it names none of them. A deliberate policy takes the snippet above and two minutes.
- **No shipping or returns in the structured data (0 of 3).** We sell downloadable software, so there is no delivery to describe. A store with physical products should not skip this one.
- **Partial identifiers (3 of 4)**, and ratings marked *Not checked* because the product has no reviews yet - which the checker does not count against us.

That is the point of the tool: not a vanity number, but a short list of specific things to fix, each with the reason it matters.

### What a score cannot tell you

A readiness check measures whether assistants *can* read your store, not whether they *will* recommend it. Recommendations also depend on your prices, your reviews, your reputation elsewhere on the web and on how each assistant ranks results - none of which a technical check can see. The checker looks at a few public pages from the outside, from a server in Europe, without running JavaScript. It is not a security audit or a full SEO crawl. Treat a high score as a fixed foundation, not a promise.

### Checklist, in order of impact

1. Allow `OAI-SearchBot`, `ChatGPT-User`, `Claude-SearchBot`, `Claude-User`, `PerplexityBot` and `Perplexity-User` in robots.txt - and check your CDN's bot settings.
2. Publish JSON-LD `Product` with price, currency, availability, brand, image and a GTIN, MPN or SKU.
3. Add shipping details and a return policy to the structured data.
4. Publish ratings as `aggregateRating` if you have reviews.
5. Make sure product name and price are in the HTML as served.
6. Keep a sitemap with product URLs and `lastmod` dates; submit it to Google and Bing.
7. Decide on AI training crawlers and write the decision into robots.txt.
8. Serve HTTPS with HSTS and the basic security headers.
9. Add an llms.txt file.
10. [Re-run the check](https://grandnode.com/ai-readiness) after every theme change, platform upgrade or CDN rule change.

### How GrandNode handles it

[GrandNode](https://grandnode.com/download) is a free, open-source e-commerce platform for .NET. Out of the box it server-renders product pages, publishes product JSON-LD and Open Graph tags, generates a sitemap and lets you edit robots.txt per store. The [AI Visibility](https://grandnode.com/grandnode-ai-visibility) add-on goes further: an automatically generated llms.txt, AI product feeds and richer structured data, kept in sync with your catalog. Our guide to [visibility in AI assistants](https://grandnode.com/seo-ai-visibility) covers the setup step by step, and if you are on another platform and the checker shows gaps your current system cannot close, we can [quote a migration](https://grandnode.com/migration).

### Frequently asked questions

#### Does blocking GPTBot remove my store from ChatGPT?

No. `GPTBot` collects content for training OpenAI's models. ChatGPT search uses `OAI-SearchBot`, and user-initiated visits come from `ChatGPT-User`. You can block the first and allow the other two.

#### Do I need llms.txt to appear in AI answers?

Not for Google, which says it does not need AI-specific files. Some agents read llms.txt, and it is quick to write, but crawler access and structured product data matter far more.

#### Is structured data required for Google's AI Overviews and AI Mode?

Google says no special markup is required. Complete JSON-LD is still the most reliable way to state price, availability and policies - for Google's shopping features and for every other assistant.

#### Why is my score partial?

Some checks could not run: your robots.txt asked the checker not to read a page, it could not find a product page, or your site was slow. Paste the address of a product page for the most complete result.

#### Will a score of 100 get my products recommended?

It removes the technical reasons not to recommend them. Whether an assistant picks your product still depends on price, reviews, reputation and its own ranking.

#### Can I stop the checker from reading my site?

Yes. Add `User-agent: GrandNode-AI-Readiness` with `Disallow: /` to your robots.txt, or ask us to exclude your domain.

**Ready to see your own list?** [Run the free AI readiness check](https://grandnode.com/ai-readiness) - it takes about ten seconds.

- [Web page](https://grandnode.com/make-your-online-store-visible-to-chatgpt)