Sage Media Hire Us

JavaScript SEO for Shopify and React Stores: 2026 Guide

SEO November 20, 2026 · 11 min read

JavaScript SEO is the work of making sure Google can see, render and index everything your shoppers see, even when that content is built in the browser by JavaScript instead of arriving as plain HTML. Most Shopify stores are fine at the core, because Shopify themes build pages on the server with Liquid. The risk sits in the extras: review widgets, app-loaded product data, filters and infinite scroll. For React and Next.js stores and web apps, the risk can be the whole site.

You do not need to read code to find most problems. You need to compare what your server sends with what Google ends up with after running your scripts. This guide is a rendering audit you can run in an afternoon, with a checklist to forward to your developer.

Why now? Google's documentation updates log shows it removed an outdated section from its JavaScript SEO basics page on 4 March 2026, documented on 24 March 2026 that it processes robots meta tags placed outside the HTML head, and on 10 July 2026 clarified how long canonical changes take to be re-evaluated. None is dramatic alone, but together they are a good prompt to check what Google actually sees on your store.

How does Google index a JavaScript website?

Google's JavaScript SEO basics page describes three phases: crawling, rendering and indexing. Googlebot fetches the page, then queues it for rendering, where a headless Chromium browser (a browser with no screen) runs your JavaScript. Google says a page "may stay on this queue for a few seconds, but it can take longer than that." It then indexes the rendered HTML.

The key line for owners: "If the content isn't visible in the rendered HTML, Google won't be able to index it." Google also notes that not all bots can run JavaScript, which matters for AI tools reading your pages; our Google AI Mode checklist covers that side.

Check afterwards: list which page types (home, collection, product, blog) rely on scripts for main content. That list sets your audit priorities.

Step 1: Compare view source with the rendered page

Open a product page in Chrome, right-click and choose "View page source". That is the raw HTML your server sent. Search it with Ctrl+F for the product name, price, a line of description and a phrase from one review. Then right-click the page and choose "Inspect": the Elements panel shows the page after JavaScript has run.

Content in the source is safe. Content that only appears in Inspect depends on rendering, which is where things go wrong.

Example: a Delhi D2C skincare brand on Shopify finds the title, price and description in the source, rendered by Liquid. The reviews under each product are missing from the source, because a reviews app injects them with a script. Now the brand knows exactly what to test next.

Check afterwards: repeat on a collection page and a blog post, and note every element missing from the source.

Step 2: Use URL Inspection to see Google's rendered HTML

Your browser is not Googlebot. Google recommends using "the Rich Results Test or the URL Inspection Tool and look at the rendered HTML." In Search Console, inspect the product URL, test it and open the rendered HTML. Search for the same phrases from Step 1.

If something is missing, a script may be blocked, failing, or waiting for a click. Google says it "won't render JavaScript from blocked files or on blocked pages", so make sure robots.txt does not block the script files your theme and apps need.

Check afterwards: keep a sheet with URL, phrase, and whether it appeared in the source, your browser and Google's rendered HTML. That sheet is your evidence for the developer.

Step 3: Find content hidden behind clicks and scrolls

As general practice, assume Googlebot will not click "Read more", open a tab that fetches content on click, or scroll to load more reviews. Text that sits in the HTML but is visually collapsed is fine; text fetched only after a click is not.

Test it: in Inspect, search for text from a closed tab such as "Shipping and returns" before clicking. If it is there, it is in the HTML.

Example: a Dubai property portal built in React loads amenities, floor plans and payment plans only when a visitor clicks each tab. The page Google indexes may show little more than a price and photos, which looks thin next to competitors.

Check afterwards: list every tab, accordion and "load more" control on key templates and mark whether its content exists before interaction.

Step 4: Make every important link a real anchor link

Google is explicit: it "can only discover your links if they are <a> HTML elements with an href attribute." A button with a click handler, or a span styled as a link, works for shoppers but gives Google nothing to follow. Its update log also notes that inserting crawlable links with JavaScript is fine, so the test is the shape of the link, not how it got there.

In Inspect, right-click a menu item, a product card and a pagination link. You want an <a> tag with an href holding a normal URL. For single-page apps, Google advises the History API for routing, not URL fragments (the part after a # sign).

Check afterwards: navigation, product grids, breadcrumbs and pagination all use real <a href> links.

Step 5: Check titles, canonicals and noindex set by script

Google says JavaScript can set or change the title and meta description. It works, but depends on rendering, so server-rendered titles are the safer default.

Canonical tags tell Google which URL is the main version of a page. Google says "the best way to set the canonical URL is to use HTML", and if you must use JavaScript, "make sure that you always set the canonical URL to the same value as the original HTML."

Noindex carries the biggest risk. Google says that on seeing noindex it "may skip rendering and JavaScript execution", so removing noindex with JavaScript "may not work as expected." If an app or leftover staging setting puts noindex in the original HTML and a script removes it later, Google may never run that script. Google's advice: if you want a page indexed, keep noindex out of the original code.

Check afterwards: search the source for "noindex" and "canonical" on every template and compare with the rendered HTML.

Step 6: Fix lazy loading, infinite scroll and filter URLs

Lazy loading loads images only when they are about to appear on screen. Google calls it "a good strategy" and points to its lazy-loading guidelines. The trap is loading that waits for a scroll, which Googlebot will not do like a shopper. Check that product images have real URLs in the rendered HTML.

As general practice, every page of a long collection should also exist as its own linked URL, such as ?page=2, so products beyond the first screen can be found. Filters are the opposite problem: colour, size and price combinations can create thousands of URLs. Give the few worth ranking, such as cotton kurtas, a proper collection page, and keep the rest from competing.

Check afterwards: confirm in URL Inspection that page 2 of a large collection shows different products.

Client-side React versus server-side rendering and static generation

A React app rendered only in the browser (client-side rendering) sends a nearly empty HTML shell, so every page depends on Google's render queue, and other crawlers may see nothing. Server-side rendering builds the HTML on the server per request; static generation builds it in advance. Google says server-side or pre-rendering "is still a great idea because it makes your website faster for users and crawlers." Its update log also records that dynamic rendering is not a recommended solution, with server-side or static rendering suggested instead.

Next.js supports both, which is part of why businesses are choosing Next.js, but a developer can still build pages entirely in the browser. Single-page apps also risk soft 404s, where a missing product says "not found" while the server returns success. Google suggests a JavaScript redirect to a URL that returns a real 404, or a noindex tag on error pages. Our guide to 301 and 302 redirects explains status codes simply.

Check afterwards: if a listing page's source is mostly empty apart from script tags, the site is client-side rendered. Raise that first.

Shopify SEO and JavaScript: where the risk really is

Shopify themes render product and collection pages with Liquid, so core content is usually in the source. The risk comes from apps that inject reviews, size charts, FAQs or bundles with scripts, theme sections that fetch products in the browser, such as "recently viewed", and filter URLs.

If reviews matter, ask your reviews app whether it can output review text in the server HTML. Google says JSON-LD structured data can be injected with JavaScript, but that still depends on rendering, so test with the Rich Results Test. If you are weighing a custom React build, read our Shopify versus custom build comparison with rendering in mind.

Check afterwards: run Steps 1 and 2 on a page where each storefront app appears, and remove unused apps whose scripts still load.

A developer hand-off checklist

  • Product name, price, description and key reviews are in the server HTML.
  • Titles, meta descriptions and canonicals are set in server HTML; scripts never change the canonical.
  • No noindex in the original HTML of pages we want indexed.
  • All important links are <a> elements with real hrefs; no # fragment routing.
  • Tab and accordion content exists before a click; images do not wait for scrolling.
  • Paginated collections have crawlable URLs; filter combinations are controlled.
  • Missing products return a real 404 status.
  • robots.txt does not block JavaScript needed for rendering.
  • React pages that should rank use server-side rendering or static generation.

Rendering fixes often help speed too, so ask for Core Web Vitals to be measured before and after.

How to check whether it is working

After fixes go live, rerun the same tests on the same URLs. Use the URL Inspection tool in Search Console on each template and confirm your logged phrases now appear in the rendered HTML. Run the Rich Results Test on product pages with structured data. View source again to confirm key content is there without scripts, and that canonical and robots values match between source and rendered HTML.

Then search Google for an exact sentence from a product description in quotes. Give it a few weeks rather than a day; Google's July 2026 note on canonical re-evaluation time is a reminder that changes are not picked up instantly. If AI assistants matter to your shoppers, read how D2C brands get cited by ChatGPT and AI search.

Frequently asked questions

Can Google index JavaScript websites?

Yes. Google renders pages with a headless Chromium browser and indexes the rendered HTML. But rendering can wait in a queue, and anything missing from the rendered HTML cannot be indexed.

Is Shopify bad for JavaScript SEO?

No. Shopify themes render core content on the server with Liquid. Problems usually come from apps and sections that load reviews or product data with scripts, and from uncontrolled filter URLs.

Do I need server-side rendering for a React site?

For pages you want to rank, it is the safer choice. Google says server-side or pre-rendering is still a great idea and notes that not all bots run JavaScript. Pages behind a login usually do not need it.

How do I do a JavaScript SEO audit without a developer?

Compare view source with the rendered page on your main templates, then check Google's rendered HTML with URL Inspection. Look for missing content, links that are not real anchors, and noindex or canonical tags that differ. Hand the evidence to a developer.

If you would like a second pair of eyes, our SEO team can run this audit across your templates and apps and write the developer brief for you, for D2C brands and web apps in India and the UAE, including from our Dubai office.