It depends on the crawler, and for most AI crawlers the answer is that you should assume no. Googlebot runs JavaScript: Google states that Google Search runs JavaScript with an evergreen version of Chromium, and it describes its processing in three phases, crawling, rendering, and indexing. For the AI crawlers, no vendor page verifies that they run JavaScript, so a store that relies on scripts to show its products is taking a risk it cannot measure. The safe rule is simple: if the product name, the price, and the stock status are not in the HTML your server sends first, most AI crawlers cannot see them.
That rule matters because of how a JavaScript website works. On a site built with a client side framework, the server sends a mostly empty page: a shell with a few divs and a script tag. The browser downloads the script, runs it, fetches the product data, and fills in the page. A shopper sees a finished page. A crawler that does not run the script sees the shell. The price was never in the response the crawler received, so no amount of good copy fixes it. The fix is not better copy. It is putting the facts in the first response.
How it works
Google processes JavaScript pages in three phases. First, crawling: Googlebot requests the address, checks whether robots.txt allows it, and parses the initial HTML response for links. Google states that it will not render JavaScript from blocked files or on blocked pages. Second, rendering: Googlebot queues pages with a 200 status code for rendering, unless a robots meta tag or header tells Google not to index the page, and a headless Chromium renderer executes the JavaScript. Google states that the page may stay on this queue for a few seconds, but it can take longer than that. Third, indexing: Google uses the rendered HTML to index the page and parses it again for links.
Two sentences in Google's own guide carry the whole lesson for AI search. The first is that server side or pre-rendering is still a great idea, because it makes your website faster for users and crawlers, and not all bots can run JavaScript. The second is that Google can only discover your links if they are real link elements with an href attribute. A navigation built from clickable divs and script handlers is invisible to Googlebot until rendering, and invisible forever to a crawler that never renders.
For the AI crawlers, the picture is different, because none of them publish a statement that they run JavaScript. OpenAI's crawler documentation describes what GPTBot, OAI-SearchBot, and ChatGPT-User do, and it says nothing about executing scripts. Perplexity's crawler documentation describes PerplexityBot and Perplexity-User, and it says nothing about executing scripts. Anthropic's crawler help page describes ClaudeBot, Claude-SearchBot, and Claude-User, and it says nothing about executing scripts. Meta's crawler documentation lists its five crawlers and says nothing about executing scripts. That silence is the finding.
That assumption has one nuance worth stating plainly. Some assistants also draw on search indexes that are rendered, so a product that Google renders and indexes can reach an assistant through that index even if the assistant's own crawler never runs the script. That is a second hand path, and it depends on the index, the query, and the assistant, none of which the store controls. A store that wants its products visible in AI answers should not depend on it. Put the facts in the first response, and every path works.
Three more details decide whether Google renders a page well. First, Google needs the JavaScript and CSS files to render the page, so a robots.txt rule that blocks the script or asset directories guarantees a broken render. Second, content that only appears after a script fetches data from an API is content Google can only see after the fetch succeeds, so a slow or failing API means a partial render. Third, Google's rendering service does not retain local storage, session storage, or cookies across page loads.
The steps
Step 1. Look at what the crawlers see. Fetch a product page the way a crawler does, with no JavaScript, using the curl command from the machine-readable piece below. Read the raw HTML. If the product name, the price, the currency, and the stock status are not in there, no AI crawler except Google's rendering pipeline can see them, and even Google can only see them after rendering. The browser version of the same check is to open the page source and search for the price. What you find in the page source is what a crawler that does not run scripts sees.
Step 2. Put the critical facts in the first HTML response. The fix is to put the facts that matter for a buying answer into the initial HTML: product name, price, currency, availability, and the product description. That usually means server side rendering the product template, or pre-rendering product pages at build time. You do not need to server render the whole interactive experience. The cart drawer, the image zoom, and the reviews widget can stay client side. What has to be in the first response is the information an engine would quote.
Step 3. Keep the product schema in the initial HTML too. The JSON-LD product markup has the same requirement: it must be in the server rendered HTML, not injected by a script after load. A script tag in the head or body of the initial response works. A tag your JavaScript framework adds at runtime does not, because a crawler that never runs the script never sees it. Google's JavaScript guide states that JavaScript can be used to generate the required JSON-LD and inject it into the page, and to test the implementation, which only helps if the crawler runs the script.
Step 4. Do not block your scripts and stylesheets. Check your robots.txt file for disallow rules on script or asset directories. Google needs those files to render the page, and blocking them does not keep anything secret. It only guarantees Google renders a broken page. The same applies to the API endpoints the page calls to fetch product data: if the crawler cannot fetch them, the rendered page has no products in it.
Step 5. Use real links for navigation and product discovery. Google states that it can only discover links if they are link elements with an href attribute. For a single page application, use the History API to implement routing between views, and give each product its own address. A route that exists only as a fragment cannot be reliably resolved by Googlebot, and a product that has no address of its own cannot be crawled, rendered, or cited by any engine.
Step 6. Check what Google actually renders. In Search Console, use the URL inspection tool to see the rendered page Googlebot produces, including the rendered HTML. If the rendered HTML shows the price and the stock status, Google's pipeline works for that page. If it shows an empty shell or an error message, the render failed. Check the vendor docs in Sources for the current path to the tool.
Step 7. Re-test after every framework change. Frameworks update, templates regress, and a page that server rendered last quarter can silently go client side again after a deploy. Add the curl test from step 1 to the checks the team runs after a release, and run it on a sample of product pages, not only the homepage.
The machine-readable piece
This is a product page fragment in HTML with the critical facts in the server rendered markup, plus a Product structured data block in the same first response. The price, the currency, and the stock status appear twice: once in the visible page text, where the shopper reads them, and once in the JSON-LD block, where a machine reads them. Both carry the same values. The availability value InStock comes from the schema.org vocabulary. Replace the placeholders in square brackets with your own values, and confirm after you publish that the visible price and the structured data price still agree.
<main>
<h1>Summit Gravel Bike</h1>
<p class="price">$2,499.00 USD</p>
<p class="stock">In stock, ships in 2 business days</p>
<p>A gravel bike with a carbon frame and tubeless ready wheels, built for mixed surface rides.</p>
</main>
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Summit Gravel Bike",
"description": "A gravel bike with a carbon frame and tubeless ready wheels, built for mixed surface rides.",
"image": "https://[yourdomain.com]/images/summit-gravel-bike.jpg",
"url": "https://[yourdomain.com]/products/summit-gravel-bike",
"brand": {
"@type": "Brand",
"name": "[Your Brand]"
},
"offers": {
"@type": "Offer",
"price": "2499.00",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock",
"url": "https://[yourdomain.com]/products/summit-gravel-bike"
}
}
</script>
Check the fragment after you publish it with the curl test from step 1: fetch the product page with no JavaScript and confirm the name, the price, and the stock status are all in the raw HTML. If they are, every crawler sees them. If they are not, the page still depends on scripts, and the fix in step 2 is not finished.
What it looks like when it works
On the page, a shopper sees the product name, the price, the stock status, and the description, exactly as before. Under the surface, the same facts arrive in the first HTML response, the structured data states them in machine readable form, and the scripts and stylesheets are allowed in robots.txt. A curl fetch with no JavaScript shows the price in the raw HTML. The Search Console rendered view shows the same price after rendering. When a shopper asks an assistant about a gravel bike under a set price, the assistant can retrieve the page, verify the price and stock, and name the store, because the facts were in the response every crawler received.
A hypothetical example
Say you run a hypothetical bicycle shop on a JavaScript storefront. Your gravel bikes look beautiful in a browser, and the shop's best seller is a carbon gravel bike priced at 2,499 dollars. You run the curl test from step 1, and the raw HTML is an empty div and a bundle script tag. The price appears nowhere. Google indexes the page after rendering, late, and only when the render succeeds. The AI crawlers see the empty shell and never mention the bike. You move the product template to server side rendering, so the name, the price, and the stock status ship in the first response, and you put the same facts in the JSON-LD block in the initial HTML.
The fundamentals
These mechanics are shared across every store and covered in full in their own guides:
- •The llms.txt format and a complete sample, see our guide to writing a good llms.txt file
- •The markup AI systems read to verify facts, see our product schema guide
- •The complete crawler rule reference, see our robots.txt guide for AI search
What this guide does not cover
This guide tells you what crawlers see on a JavaScript website, not how to rebuild your frontend. The choice between server side rendering, static generation, and pre-rendering is an engineering decision with real tradeoffs, and it is outside this guide's scope. It also does not cover monitoring: frameworks update, templates regress, and a page that server rendered last quarter can silently go client side again. And visibility is not purchase: once engines can read your pages, the transaction layer is what lets an agent complete the checkout.
Check your own store now
Run the free scan. One click, no signup, and it shows what AI crawlers actually see on your product pages: aizii.ai/aeo-scan
Run the free scanSources
- Google Search Central, Understand JavaScript SEO basics (specific): https://developers.google.com/search/docs/crawling-indexing/javascript/javascript-seo-basics
- Google Search Central, Optimizing your website for generative AI features on Google Search (specific): https://developers.google.com/search/docs/fundamentals/ai-optimization-guide
- OpenAI, Overview of OpenAI crawlers (general docs): https://platform.openai.com/docs/bots
- Perplexity, Perplexity crawlers (general docs): https://docs.perplexity.ai/guides/bots
- Anthropic, Does Anthropic crawl data from the web, and how can site owners block the crawler (general docs): https://support.anthropic.com/en/articles/8896518-does-anthropic-crawl-data-from-the-web-and-how-can-site-owners-block-the-crawler
- Meta, Meta web crawlers (general docs): https://developers.facebook.com/documentation/sharing/webmasters/web-crawlers
- Schema.org, Product type (specific): https://schema.org/Product
Note: links marked specific point to the page that supports the claim in this guide. Links marked general docs point to the vendor's general docs section for that topic, not to a page that proves every step. Check the vendor docs for the current path before relying on a menu name or click path in this guide.
