To optimize your site for ChatGPT and Perplexity, do four things: allow their crawlers (GPTBot, OAI-SearchBot, PerplexityBot) in robots.txt; put your schema and key facts in server-rendered HTML they can read without JavaScript; add short answer capsules they can quote; then verify each bot gets a 200, not a 403, on your pages.
Optimizing your site for ChatGPT and Perplexity is not a rewrite — it is a short, technical checklist that makes your existing pages readable to the two engines shoppers now ask. Get it right and you become a source they quote; get it wrong and you stay invisible no matter how good your content is.
This is the step-by-step version: how each engine reads your site, the four changes that matter, the exact code shapes, and how to verify a bot actually sees your pages.
How ChatGPT and Perplexity read your site
Both engines answer the same way: a crawler fetches your page, reads the raw HTML it receives, and quotes the passages it trusts — and neither runs your JavaScript on that first pass. That single fact drives every step below. If a fact only appears after scripts run, it may as well not be on the page. Here is which crawler does what, and how to test each one.
| Engine | User-agent | What it reads | How to test |
|---|---|---|---|
| ChatGPT (training) | GPTBot | Raw HTML, for model knowledge | curl with the user-agent, expect 200 |
| ChatGPT (search) | OAI-SearchBot | Raw HTML, for live cited answers | curl with the user-agent, expect 200 |
| ChatGPT (live fetch) | ChatGPT-User | A page on demand during a chat | Ask ChatGPT to open your URL |
| Perplexity | PerplexityBot | Raw HTML, indexed for citations | curl with the user-agent, expect 200 |
| Claude (bonus) | ClaudeBot, Claude-User | Raw HTML, training and live fetch | curl with the user-agent, expect 200 |
Perplexity is the most citation-hungry of the two and leans hardest on classic search signals — roughly 29% of its citations point to pages that also rank in Google's top 10, versus about 8% for ChatGPT. Practically, that means clean structure wins you Perplexity citations fast, while ChatGPT rewards the same structure plus a stronger, more-referenced brand.
The practical consequence: the same four steps below serve both engines. You do not optimize twice — you make one set of pages readable and quotable, then let each engine apply its own weighting. Claude works the same way through ClaudeBot and Claude-User, so the effort compounds across every assistant that reads raw HTML.
The 4 steps to optimize your site
Do them in order — step 1 unblocks the rest, and step 4 proves the first three actually landed.
Allow the AI crawlers in robots.txt
Nothing else matters if the bots cannot reach you. Confirm no custom robots.txt, security app, or firewall is blocking them, then add explicit Allow rules — one block per bot — without touching Shopify's default protections on cart, checkout and internal search. Shopify allows these bots by default, so this is usually a five-minute confirmation; the failures come from apps and custom templates you forgot about.
Put your facts in server-rendered HTML
Your Product, Organization and FAQ schema, and the key facts (price, specs, answers), must ship in the initial HTML response. Most schema apps inject JSON-LD with JavaScript that these crawlers never execute — so it validates in Google's tester and is still invisible to ChatGPT and Perplexity. Emit it in Liquid instead, as one connected graph. The tell is simple: if you can find your schema only in the browser's rendered DOM and not in View Source, an engine cannot see it.
Add answer capsules the engines can quote
Lead each key page with a 40–60 word, self-contained answer to the question that page targets, in plain HTML near the top. Product pages, collections, and comparison articles benefit most, because those are the pages shoppers ask about by name. It is the passage an engine lifts verbatim — write it so it stands alone, naming the product and the fact, with no “see above.”
Verify each bot gets a 200, not a 403
Assume nothing. Fetch your own pages as each user-agent and confirm you get an HTTP 200 with your content in the body — a 403 or an empty shell means a bot is blocked or your facts are JavaScript-only. Re-check after any theme, app, or security-setting change. Automate it if you can: a scheduled fetch as each user-agent catches the day an app update silently starts returning a 403.
Step 1 is a handful of lines. Each crawler entry follows the same pattern in your robots.txt template:
User-agent: GPTBot
Allow: /
User-agent: OAI-SearchBot
Allow: /
User-agent: PerplexityBot
Allow: /Optionally, add an llms.txt that points the engines at your best pages — a short, curated map that complements robots.txt:
# llms.txt
# Your most quotable pages, in plain text
/collections/best-sellers
/pages/buying-guide
/blogs/news/your-best-comparisonFor step 2, the goal is one connected graph in the raw HTML, entities linked by @id — heavily simplified, for illustration only:
{ "@context": "https://schema.org",
"@graph": [
{ "@type": "Organization", "@id": "…#org" },
{ "@type": "Product", "@id": "…#product",
"brand": { "@id": "…#org" } },
{ "@type": "FAQPage", "@id": "…#faq" }
] }How to verify it actually works (200 vs 403)
This is the step most guides skip, and it is the one that tells the truth. Fetch your page while pretending to be each bot, and read two things: the status code and whether your facts are in the body.
curl -A "PerplexityBot" -s -o /dev/null -w "%{http_code}\n" \
https://yourstore.com/products/example
# want: 200 (403 = blocked)Then fetch the full body and search it for a sentence you can see on the rendered page — a spec, your answer capsule, a line of your description:
curl -A "GPTBot" -s https://yourstore.com/products/example | grep -c "your visible sentence"
# want: 1 or more (0 = the text is JavaScript-only)Do the same with a browser: open View Source (not the rendered DOM) and search for application/ld+json and your key facts. If they are not in the source, the engine is not getting them. For a full read across every signal at once, a free audit fetches your store the way these crawlers do and scores what survives.
If a bot returns 200 and your visible sentence appears in the raw body, that engine can read and quote you. If either check fails, no amount of content will help until it is fixed.
The four things that make a page fail the test
When a bot returns a 403 or your sentence is missing from the body, it is almost always one of these. Each looks fine in a browser and breaks silently for the crawler.
A crawler is disallowed
A custom robots.txt or a security or bot-protection app quietly blocks GPTBot or PerplexityBot. You get a 403, and no content ever reaches the engine.
Schema is JavaScript-injected
An app writes your JSON-LD after load. It passes Google's tester, which renders JavaScript, and stays invisible to ChatGPT and Perplexity, which do not.
Content is lazy-loaded or hidden
Specs behind a tab, descriptions that load on scroll, or facts baked into images — all absent from the raw HTML the crawler reads once.
The answer is buried
Even a readable page gets skipped when the quotable fact is three scrolls down. No self-contained answer near the top means nothing clean to lift.
Why this is worth the afternoon
AI answers are a parallel channel with their own entry requirements, and structure — not domain size — is what gets a smaller store cited. Across our own tracking, well-structured, readable pages earn citations far out of proportion to their traffic, because the engine quotes whoever it can cleanly parse.
The takeaway behind those numbers: you do not have to outrank anyone to be cited. You have to be the page an engine can read on the first fetch, with the answer sitting in plain sight. That is what these four steps deliver. For the deeper mechanics of why so much content never reaches a crawler, see why Shopify product pages are invisible to AI, and for the full checklist, our guide to Shopify answer engine optimization.
Steps 1 and 2 — a crawler-safe robots.txt and one server-rendered schema graph — are exactly what the AI-Ready Kit Pro ($199) ships, pre-built and update-resistant, in about 90 minutes, with llms.txt and answer capsules included. Browse the AI-Ready Kits to match a tier to your store.
Run the verification above on one product page today — or let a free AI-readiness audit do it across your store, fetching your pages the way a crawler does and scoring what survives, at audit-tool-delta.vercel.app. Then install the full stack with the AI-Ready Kits, or book expert help.