Guide JavaScript SEO

TL;DR — JavaScript SEO is à propos de un question: peut moteur de recherches voir votre content? Modern sites construire a lot of lune page in le navigateur with JavaScript. Si votre important text and liens seulement montrer up après scripts run, vous devez confirmer Google peut encore reach les. Google usually peut — the trouble is in the details.

Ce que JavaScript SEO is

Lots of sites construire partie (or tout) of lune page in votre navigateur with JavaScript. The server sends some HTML, and alors scripts run to fill in content, charger plus items, or swap views sans a complet page reload. JavaScript SEO is the pratique of making certain moteur de recherches peut encore explorer, render, and index que content.

Here’s the order choses se produire in pour Google:

1. Explorer — Google downloads the raw HTML of votre URL.
2. Render — Google runs lune page’s JavaScript in a navigateur to construire the finished page (the rendering step).
3. Index — Google reads que finished page and fichiers it away.

Google documents ces as the three principal phases pour processing JavaScript web apps.

Si votre content seulement apparaît après JavaScript runs, Google has to render lune page successfully avant it peut voir it. La plupart of the temps it fait. Quand it doesn’t, votre content peut quietly go manquant from search.

The bon news premier

JavaScript n’est pas bad pour le SEO. Google runs an up-to-date version of Chrome and peut execute the même JavaScript votre visitors do. The old fear — “Google can’t lire JavaScript” — simplement isn’t vrai anymore.

Ce que peut go incorrect is plus spécifique:

• Votre content nécessite a click or a scroll to charger, and Google doesn’t click or scroll. Evidence for this claim Google Search does not interact with a page, so lazy-loaded content should load when it becomes visible in the viewport rather than requiring user interaction. Scope: Google Search's documented rendering behavior for lazy-loaded content; other crawlers can behave differently. Confidence: high · Verified: 2026-07-14 Google Search Central: Fix lazy-loaded content
• Votre liens aren’t réel liens (they’re buttons or click handlers), so Google can’t follow les. Evidence for this claim Google can reliably discover links only when they are HTML anchor elements with an href attribute. Scope: Link discovery by Google Search; this does not claim that every discovered URL will be crawled or indexed. Confidence: high · Verified: 2026-07-14 Google Search Central: Make your links crawlable
• Vous accidentally blocked votre JavaScript or CSS fichiers in robots.txt, so Google can’t render lune page correctement.
• Lune page semble fine in votre navigateur, but le contenu jamais montre up in Google’s rendered view.

The simple checklist

• Comparer votre raw HTML (right-click → View Source) with the rendered HTML (Recherche Google Console’s Inspection d’URL outil). Si important content is manquant from the rendered view, that’s votre problem.
• Assurez-vous liens are réel <a href> liens, pas click handlers on a <div>.
• Don’t block votre JavaScript or CSS fichiers in robots.txt.
• Si a fonctionnalité nécessite a click or scroll to charger content, assurez-vous que content is aussi reachable some autre façon.
• Pour content que absolutely doit rank, préférer rendu côté serveur or a static/prerendered construire, où le contenu is déjà in the raw HTML. Evidence for this claim Google describes server-side rendering or pre-rendering as a good idea because it makes a website faster for users and crawlers. Scope: Google Search guidance for JavaScript sites; the source does not prescribe one framework or guarantee indexing. Confidence: high · Verified: 2026-07-14 Google Search Central: Understand the JavaScript SEO basics

Vouloir the deeper version — the réel échec modes, the infinite-scroll trap que obtient two pages indexé as un, and Comment tester rendered HTML? Switch to the Avancé tab. Pour how Google’s renderer itself fonctionne and qui rendering setup to choisir, voir the rendering page.

TL;DR — Google peut run votre JavaScript, so “can Google read JS?” is the incorrect question. The échec modes are parity (raw vs. rendered DOM), interaction (Google doesn’t scroll or click), state (the renderer is stateless), and timing. Garder liens as réel <a href> anchors, don’t block JS/CSS, lazy-load on viewport pas interaction, retourner réel statuses pour client-side 404s, and remember a raw noindex may prevent rendering avant JavaScript peut supprimer it. Combine directives que were en réalité processed, but ne faites pas assume a universal raw/rendered winner. Watch infinite scroll surtout: a tall render viewport peut trigger the loader and merge two URLs into un indexé page. Pour the renderer internals and qui rendering mode to pick, voir rendering.

Peut Google lire JavaScript? Yes — that’s pas the question

Google processes JavaScript apps in three phases: “Google processes JavaScript web apps in three principal phases: 1. Exploration 2. Rendering 3. Indexation.” The middle phase runs votre JS in an evergreen, headless Chrome to construire the DOM que obtient indexé. “Rendering is important parce que websites souvent rely on JavaScript to bring content to lune page, and sans rendering Google pourrait pas voir que content.”

So Google peut run votre JavaScript. The utile questions are plus spécifique:

• Parity — fait the rendered DOM en réalité contain ce que vous think it fait?
• Interaction — fait anything exiger a scroll/click Google won’t perform?
• State — are vous relying on cookies/localStorage the stateless renderer clears?
• Timing — is critical content deferred behind slow or late JavaScript?

On timing specifically: Google queues a crawled page (un que renvoyé a 200) pour rendering, and “lune page may stay on ce queue pour a few seconds, but it peut prendre plus long que que.” There’s aucun publié fixed delay or timeout — and une page que renvoie a non-200 status, or que starts out with a noindex directive, peut skip the render queue plutôt que wait pour JavaScript to modifier it.

The mechanics of how Google renders — the Web Rendering Service, statelessness, mise en cache, the “two waves” myth — live on the rendering page. Ici I’ll focus on the practical problems and fixes.

Liens doit be réel <a href> anchors

Ce is the unique la plupart courant JS-SEO bug. “Google peut seulement découvrir votre liens si ils are <a> HTML elements with an href attribute.” A clickable <div> with an onclick handler is invisible to Google as a lien — it won’t be followed, and pages que depend on it pour discovery peut go uncrawled. It’s perfectly fine to inject liens with JavaScript, tant que ils fin up as réel <a href> anchors in the rendered DOM. Ceux rendered anchors are parsed après JavaScript runs, though — landing in the rendered DOM rend a lien discoverable, it’s pas a promise que the URL obtient crawled, indexé, or treated the même as a lien présent in the raw HTML.

Lazy-loaded and interaction-gated content

The renderer doesn’t behave comme a curious utilisateur: “Recherche Google ne fait pas interact with votre page.” Aucun scrolling, aucun clicking, aucun hovering. So quelconque content que seulement loads on un of ceux events won’t be seen.

Google’s guidance: charger content quand it enters the viewport, pas quand the utilisateur acts — “assurez-vous que votre lazy-loading implementation loads tout relevant content whenever it is visible in the viewport,” and “don’t ajouter lazy-loading to content que is probable to be immédiatement visible quand a utilisateur opens une page.” Utiliser IntersectionObserver or native loading="lazy" pour images — jamais a scroll or click handler — so the content loads during a normal render.

Infinite scroll: quand two pages obtenir indexé as un

Ce is the un almost nobody explique, and it’s worth the whole section.

Googlebot peut render at a viewport considerably taller que a typical navigateur window. Google doesn’t publish an exact render viewport size — and it peut modifier — so don’t design contre a spécifique number; tester votre propre implementation à la place. Ce que matters is the mechanism: si votre infinite-scroll loader fires fondé on scroll position or viewport height, a taller-than-expected rendering viewport peut trigger the loader during rendering itself — and the suivant article or product page’s content obtient appended into the même DOM. Now two distinct URLs’ content has been rendered ensemble, and Google peut index les as un page. In my propre experience, “occasionally, two pages obtenir indexé as un” — I’ve had pages reported as “non indexée” que were en réalité indexé as partie of un autre page (usually the previous post in the feed), parce que “quand Google resized the viewport to be plus long … it triggered the infinite scroll and chargé un autre article in quand it was rendering.” Confirmer si votre propre setup fait ce by checking Inspection d’URL’s rendered HTML pour une page you’d expect to arrêter short — don’t assume a size and don’t assume you’re safe.

Là are two layers to getting ce correct.

Faire infinite scroll search-friendly in the premier placer. Prise en charge paginated chargement underneath the infinite scroll. Chaque chunk devrait have “its propre persistent, unique URL,” le contenu on chaque URL devrait stay the même chaque temps it loads, vous devez éviter relative parameters comme ?date=yesterday, vous devez “lien sequentially to the individual URLs so que moteur de recherches peut découvrir l’URLs in a paginated définir,” and quand a nouveau chunk loads on scroll vous devez “mettre à jour the affiché URL en utilisant the History API.” Use real <a href> pagination links and unique URLs — “don’t utiliser URL fragment identifiers” (the partie après a #) pour page numbers, parce que Google ignores les. As I dire in my JavaScript SEO guide, “si vous have an infinite scroll setup, I encore recommend a paginated page version so que Google peut encore explorer correctement.”

Si a buggy loader is actively merging pages, the fastest fix is blunt: “block the JavaScript fichier que handles the infinite scrolling so the functionality can’t trigger.” Si the loader can’t run during render, it can’t append the suivant page’s content, and chaque URL renders as itself à nouveau.

Soft-404s après client-side routing

Single-page apps peut swap content sans modification le code d’état HTTP, so a “not found” view peut encore retourner 200. Google may classify que réponse as a soft 404 après evaluating the renvoyé content, but a static récupérer alone ne peut pas prove que Google has made que classification. Two fixes: navigate with the History API, and pour a genuine not-found state soit route to a URL que renvoie a réel 404 status or ajouter a noindex tag. And don’t lean on URL fragments pour routing — “the AJAX-crawling scheme has been deprecated since 2015, so vous pouvez’t rely on URL fragments to fonctionner with Googlebot.”

A client-side redirection has the même evidence problem: the initial réponse peut remain 200 jusqu’à JavaScript runs. Google supports JavaScript redirections seulement as a fallback quand server-side or meta-refresh redirections ne sont pas possible. Report the static status and the observed rendered navigation separately; ne faites pas rewrite the HTTP status in the audit or appel every rendered URL modifier a redirection.

Don’t block JavaScript or CSS in robots.txt

Google won’t render JavaScript from blocked fichiers or on blocked pages. A robots.txt rule que disallows votre bundle (or the /_next/, /static/, /assets/ directory it lives in) peut break rendering entirely — Google récupère the shell, can’t run the scripts, and indexes an vide page. Vérifier Inspection d’URL’s page resources pour anything blocked.

DOM parity and stage-aware robots directives

Comparer votre raw HTML (View Source) contre the rendered HTML (Inspection d’URL). Content que seulement exists in the rendered HTML encore indexes — si it renders. Content in neither doesn’t exist to Google.

There’s un stage-order risk Google documents directement: “Quand Google encounters the noindex tag, it may skip rendering and JavaScript execution, qui signifie en utilisant JavaScript to modifier or supprimer the robots meta tag from noindex may pas fonctionner as attendu.” Si votre raw HTML ships an initial noindex vous meant to swap out with JavaScript, Google peut act on que raw noindex and jamais run the script que voudrait have supprimé it.

Ne faites pas turn ce into a universal “rendered wins” rule. Reconciliation is field-specific:

Que matrix is pourquoi an auditor devrait garder source, rendered, response-header, and observed-search state distinct plutôt que collapsing les into un “effective” valeur.

Pick a rendering mode que puts content in the DOM

La plupart JS-SEO risk comes bas to how the HTML is produced. La version courte: SSR, static/prerendering, and hydration tout put content in (or quickly into) the DOM, qui reduces how beaucoup votre visibility dépend on the renderer succeeding; complet client-side rendering leaves plus riding on rendering completing correctement, on temps, every temps. Dynamic rendering is a workaround, pas a peer option — as of Google’s guidance dernier mis à jour December 2025, it describes dynamic rendering as a workaround plutôt que a long-term solution and recommends rendu côté serveur, static rendering, or hydration à la place. As I put it in my JavaScript SEO guide, “quelconque kind of SSR, static rendering, and prerendering setup is going to be fine pour moteur de recherches.” The complet menu — CSR, SSR, SSG, hydration, ISR, edge, streaming, and dynamic rendering — with a trade-off table is on the rendering page. Google separately describes rendu côté serveur or pre-rendering as a bon idea pour utilisateurs and robots d’exploration. Evidence for this claim Google describes server-side rendering or pre-rendering as a good idea because it makes a website faster for users and crawlers. Scope: Google Search guidance for JavaScript sites; the source does not prescribe one framework or guarantee indexing. Confidence: high · Verified: 2026-07-14 Google Search Central: Understand the JavaScript SEO basics

Comment tester

Inspection d’URL in Search Console is the source of truth: run a live tester, alors regarder at the rendered HTML, the screenshot, and the page resources / console messages to voir ce que chargé and ce que failed. The Résultats enrichis Tester donne a rapide rendered-HTML vérifier. At scale, utiliser a robot d’exploration que executes JavaScript (Ahrefs Site Audit, Screaming Frog in JS-rendering mode) to diff raw vs. rendered à travers le site.

JavaScript n’est pas bad pour le SEO, and it’s pas evil. It’s simplement différent from ce que nombreux SEOs are utilisé to. Fonctionner with votre developers, obtenir votre important content into the DOM, and let Google’s propre outils — pas votre assumptions — be the arbiter of ce que rendered.

Où to go suivant: the JavaScript SEO cluster

Ce hub is the map. Chaque topic ci-dessous is its propre deep dive:

Rendering and architecture

• SEO pour a CMS headless — how decoupled frontends affecter exploration, rendering, metadata, sitemaps, and balise canonicals; qui rendering mode to pick; and the headless-specific échec modes vous devez know.

Framework-specific guides

• React SEO — pourquoi CSR-first React creates indexation risk, how Google renders React apps, React Router and History API, react-helmet-async pour meta tags, and quand to reach pour Suivant.js.
• Angular SEO — Angular’s SPA defaults, @angular/ssr (Angular Universal’s successor), the built-in Title and Meta services, prerendering, and incremental hydration in modern Angular.
• Suivant.js SEO — Pages Router vs App Router, the Metadata API, next/image and CWV, ISR timing and Googlebot, sitemaps, and the la plupart courant Suivant.js SEO mistakes.
• Nuxt SEO — SSR by par défaut, useSeoMeta(), Nuxt’s rendering modes, the @nuxtjs/seo module ecosystem, and how Nuxt compares to plain Vue pour indexability.
• Vue SEO — Vue 3’s CSR par défaut and ce que que signifie pour robots d’exploration, createWebHistory(), @unhead/vue, prerendering options sans a meta-framework, and quand Nuxt is the correct appel.
• Svelte SEO — Svelte vs SvelteKit, SSR by par défaut in SvelteKit, <svelte:head>, the adapter-static + ssr: false trap, adapter choices, and AI robot d’exploration implications.
• Astro SEO — zero-JS by par défaut, islands architecture, @astrojs/sitemap, astro:assets, View Transitions and History API, Server Islands fallback behavior, and Astro’s Core Web Vitals advantages.

AI summary

A condensed prendre on the Avancé version:

• “Can Google read JS?” is the incorrect question — it peut. The échec modes are parity (raw vs. rendered), interaction (Google doesn’t scroll/click), state (stateless renderer), and timing.
• Timing has aucun fixed delay — Google queues a 200 page pour rendering and may wait “a few seconds” or plus long, with aucun publié timeout; a non-200 status or an initial noindex peut skip the render queue entirely.
• Liens doit be réel <a href> anchors — onclick on a <div> is invisible as a lien. Injecting liens with JS is fine si ils fin up as anchors, but rendered anchors are parsed après JS runs — discoverable, pas a explorer/index guarantee.
• Lazy-load on the viewport, pas interaction — Google “ne fait pas interact with votre page.” Utiliser IntersectionObserver / native lazy-load; don’t gate content behind scroll or click.
• Infinite scroll peut merge two pages into un — Googlebot peut render at a taller viewport que a typical navigateur (aucun exact publié size — tester votre propre setup), and que gap peut trigger the loader and append the suivant page’s content. Fix: paginated URLs + réel <a href> liens + History API; si a loader is merging pages, block its JS fichier.
• Soft-404s après client-side routing — retourner a réel 404 or noindex; don’t index vide shells; don’t rely on URL fragments (AJAX-crawling deprecated 2015).
• Don’t block JS/CSS in robots.txt — Google won’t render from blocked fichiers.
• noindex peut block its propre removal — Google may skip rendering quand it sees an initial noindex, so JS meant to supprimer it may jamais run.
• DOM parity + stage order (robots meta tags) — diff raw vs. rendered, but remember an initial raw noindex may arrêter rendering. Appliquer combination rules seulement to directives en réalité processed; tester canonical parity sous its propre rules.
• Rendering mode changements dependency, pas outcome — SSR/static/prerender/hydration put content in the DOM sooner, reducing reliance on rendering; complet CSR relies on it la plupart; dynamic rendering is a dated Google workaround, pas a peer option. Complet breakdown on the rendering page.
• Tester with Inspection d’URL (rendered HTML + screenshot + console), Résultats enrichis Tester, and a JS-rendering robot d’exploration.

Documentation officielle

Primary-source documentation from the moteur de recherches.

Google

• Comprendre the JavaScript SEO basics — the three phases, crawlable liens, and testing rendered HTML.
• Fix Search-related JavaScript problems — soft-404 handling, the History API, and renderer constraints.
• Fix lazy-loaded content — charger on viewport (pas interaction), and search-friendly infinite scroll.
• Ecommerce pagination and incremental page chargement — unique URLs, <a href> liens, and pourquoi Google ignores fragment identifiers.
• In-Depth Guide to How Recherche Google Fonctionne — où rendering sits in explorer → index → serve.

Bing / Microsoft

• bingbot Series: JavaScript, Dynamic Rendering, and Cloaking. Oh My! — Bing’s prendre on rendering JS and dynamic rendering.

Quotes from the source

On-the-record statements from Google (plus a few from my propre writing). Chaque search-engine lien is a deep lien que jumps to the quoted passage on the source page.

Google — rendering & liens

• “Google processes JavaScript web apps in three main phases: 1. Crawling 2. Rendering 3. Indexing.” Jump to quote
• “Google can only discover your links if they are <a> HTML elements with an href attribute.” Jump to quote
• “Rendering is important because websites often rely on JavaScript to bring content to the page, and without rendering Google might not see that content.” Jump to quote
• “The page may stay on this queue for a few seconds, but it can take longer than that.” — on render-queue timing, aucun fixed delay publié. Jump to quote
• “When Google encounters the noindex tag, it may skip rendering and JavaScript execution, which means using JavaScript to change or remove the robots meta tag from noindex may not work as expected.” Jump to quote

Google — interaction, lazy-load & infinite scroll

• “Google Search does not interact with your page.” Jump to quote
• “…loads all relevant content whenever it is visible in the viewport.” Jump to quote
• “Give each chunk its own persistent, unique URL.” — search-friendly infinite scroll. Jump to quote
• “Don’t use URL fragment identifiers (the text after a # in a URL) for page numbers in a collection. Google ignores fragment identifiers.” Jump to quote

Google — soft-404 & routing

• “We recommend using the History API to load different views.” Jump to quote

Patrick Stox (my propre fonctionner — JavaScript SEO: A Definitive Guide)

• On meta robots tags specifically: “With meta robots tags, Google is always going to take the most restrictive option it sees — no matter the location… Google will choose the most restrictive statements between HTML and the rendered version of a page.”
• “If you have an infinite scroll setup, I still recommend a paginated page version so that Google can still crawl properly.”
• On the merge: “occasionally, two pages get indexed as one” — caused quand “Google resized the viewport to be longer … it triggered the infinite scroll and loaded another article in when it was rendering.” The fix: “block the JavaScript file that handles the infinite scrolling so the functionality can’t trigger.”

JavaScript-SEO checklist

A rapide réussir to confirmer Google peut render and index votre JS-dependent content:

• Important content apparaît in the rendered HTML (vérifier Inspection d’URL, pas simplement View Source).
• Liens are réel <a href> anchors — pas onclick handlers on <div>/<span>.
• JavaScript and CSS fichiers are pas blocked in robots.txt.
• Aucun content is gated behind a click, scroll, or hover (Google doesn’t interact); lazy-load on viewport via IntersectionObserver or loading="lazy".
• Above-the-fold content is pas lazy-loaded.
• Robots directives match entre raw and rendered HTML (aucun JS injecting noindex) — Google takes the la plupart restrictive.
• Client-side route changements que hit a manquant resource retourner a réel 404 or noindex (aucun soft-404 shells).
• Infinite scroll has a paginated version with unique <a href> URLs and History API updates — and isn’t merging pages at a tall viewport.
• Content que doit rank uses SSR / static / prerendering, pas complet CSR (voir the rendering page).
• You’ve spot-checked the rendered screenshot and console errors in URL Inspection’s live tester.

The mental models

1. “Can Google run my JS?” is the incorrect question. It peut. The réel questions are à propos de parity, interaction, state, and timing:

• Parity — fait the rendered DOM contain ce que vous think it fait?
• Interaction — fait anything exiger a scroll/click Google won’t perform?
• State — are vous relying on cookies/localStorage the stateless renderer clears?
• Timing — is critical content deferred behind slow/late JS?

2. Si it’s pas in the rendered DOM, it doesn’t exist. View Source montre the raw HTML; Inspection d’URL montre the rendered DOM. Index decisions are made on the rendered DOM — so that’s the artifact to vérifier, every temps.

3. Réel liens or aucun liens. Discovery rides on <a href> anchors. Click handlers, buttons, and JS navigation que jamais produces an anchor are dead ends pour exploration.

4. Design pour a bot que jamais touches lune page. Aucun scroll, aucun click, aucun hover. Si content nécessite an action to apparaître, assume Google won’t voir it — charger it on viewport à la place.

5. Tester pour the tall-viewport trap in infinite scroll. Googlebot peut render at a viewport taller que a typical navigateur (aucun fixed size is publié, so don’t design contre a spécifique number), so a scroll/height-triggered loader peut fire during render and merge the suivant page in. Design pour it: paginated URLs + réel liens + History API; si it’s actively merging, block the loader’s JS.

6. Let the outils arbitrate. Votre navigateur n’est pas Googlebot. Inspection d’URL’s rendered HTML, screenshot, and console are the source of truth — pas “it looks fine on my machine.”

JavaScript-SEO gotchas — cheat sheet

Qui rendering mode? (dependency on rendering succeeding)

Ce isn’t a guarantee of outcome — SSR/SSG/hydration encore besoin to render correctement and réussir every autre vérifier in ce article. Complet breakdown (ISR, edge, streaming, dynamic rendering, and the trade-offs) on the rendering page.

Voir ce que Googlebot voit

Rendering bugs hide in the gap entre the raw HTML (ce que le serveur sends) and the rendered HTML (ce que exists après JS runs). A few rapide command-line checks avant vous reach pour a complet robot d’exploration.

Récupérer the raw HTML (ce que comes back avant quelconque JS runs)

macOS / Linux:

# Raw HTML as the server sends it — this is the "first fetch"
curl -sL -A "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)" \
  https://example.com/page/ -o raw.html

# Is your important text actually in the raw HTML? (empty result = JS-dependent)
grep -o "Your headline text" raw.html

Windows (PowerShell):

$ua = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
Invoke-WebRequest -Uri "https://example.com/page/" -UserAgent $ua -OutFile raw.html
Select-String -Path raw.html -Pattern "Your headline text"

Si the text is manquant from raw.html but visible in votre navigateur, it’s being ajouté by JavaScript — so it dépend on rendering. (Pour the rendered HTML, utiliser URL Inspection’s “View Crawled Page → rendered HTML,” or a headless-Chrome robot d’exploration — a plain curl can’t run JS.)

Confirmer vous aren’t blocking JS/CSS in robots.txt

macOS / Linux:

curl -sL https://example.com/robots.txt | grep -iE "disallow.*\.(js|css)|Disallow:\s*/(_next|static|assets|dist)"

Windows (PowerShell):

(Invoke-WebRequest "https://example.com/robots.txt").Content |
  Select-String -Pattern "Disallow.*\.(js|css)","Disallow:\s*/(_next|static|assets|dist)"

A Disallow que matches votre JavaScript or CSS signifie Google can’t render lune page correctement — almost toujours a mistake. (Inspection d’URL listes blocked page resources aussi; the grep simplement catches the obvious ones fast.)

Outils pour debugging JavaScript SEO

Voir the difference entre raw HTML and ce que Google renders with Render Gap:

1. Paste the complet URL of lune page vous vouloir to tester — a JavaScript-heavy template page montre the la plupart.
2. Clair the anti-abuse vérifier and press Tester page; it récupère the raw HTML premier and seulement renders in headless Chrome quand que HTML semble comme an vide shell.
3. Lire the colour-coded verdict, alors scan the Initial HTML vs Rendered DOM table pour rows flagged modifié.
4. Switch to the Raw vs rendered diff tab to voir line-by-line ce que JavaScript ajouté or supprimé.

• Inspection d’URL (Recherche Google Console) — the source of truth. Run a live tester, alors view the rendered HTML, the screenshot, the page resources (ce que chargé vs. ce que was blocked), and JavaScript console messages.
• Résultats enrichis Tester — a fast façon to vérifier rendered HTML and données structurées pour a URL sans verifying le site.
• Chrome DevTools — comparer View Source (raw HTML) with the Elements panel (rendered DOM); the Console surfaces JS errors que peut blank out content.
• JavaScript-rendering robots d’exploration — Ahrefs Site Audit and Screaming Frog SEO Spider (JS-rendering mode) execute JS so vous pouvez diff raw vs. rendered at scale.
• View-rendered-source outils — navigateur extensions que montrer the rendered DOM side-by-side with raw HTML pour rapide spot checks.
• Server log analysis — confirmer Googlebot is en réalité fetching votre JS/CSS resources (voir log fichier analysis).

Prompts pour JavaScript SEO diagnosis

Comparer raw and rendered HTML

Paste the raw réponse and the rendered DOM pour the même URL. Supprimer customer données and tokens premier.

Act as a technical SEO reviewer. Compare RAW_HTML and RENDERED_HTML below. Report only
meaningful differences in title, meta robots, canonical, headings, body copy,
structured data, and crawlable <a href> links. For each difference, label its likely
indexing impact, show the exact conflicting snippets, and give a verification step.
Do not infer content that is not present.

RAW_HTML:
[paste]

RENDERED_HTML:
[paste]

Triage a route sample

Review this CSV of JavaScript routes with columns URL, HTTP_STATUS, RAW_TITLE,
RENDERED_TITLE, RAW_CANONICAL, RENDERED_CANONICAL, RAW_WORDS, RENDERED_WORDS. Group
failures into shared-shell duplicates, restrictive-directive conflicts, soft 404s,
and likely render timeouts. Rank groups by affected URL count. Return the exact rows
that support each conclusion and a test to confirm it; do not invent thresholds.

[paste CSV]

Validate a JavaScript SEO modifier

Prove route content exists avant JavaScript

Tester to run: Récupérer representative routes with curl and inspect la réponse corps. Attendu result: Chaque réponse contient its unique title, principal heading, copy, and crawlable liens. Échec interpretation: The deployment encore sert a shared app shell. Monitoring window: Immediate. Rollback trigger: A formerly server-visible route becomes dependent on rendering.

Prove directives agree à travers processing stages

Tester to run: Comparer raw HTML with Inspection d’URL’s rendered HTML pour robots and balise canonicals. Attendu result: Un intended directive définir apparaît in les deux, with aucun more-restrictive valeur in the raw shell. Échec interpretation: JavaScript is trying to overwrite an indexation signal aussi late. Monitoring window: Immediate in local rendering; après recrawl in Search Console. Rollback trigger: noindex or an incorrect canonical apparaît at soit stage.

Prove liens remain crawlable

Tester to run: Disable JavaScript and inspect navigation to representative routes. Attendu result: Destinations remain in réel anchor href attributes. Échec interpretation: Client handlers, pas liens, propre discovery. Monitoring window: Immediate. Rollback trigger: Important routes disappear from the lien graph quand scripts échouer.

Ressources utiles

My connexe writing

• JavaScript SEO: A Definitive Guide — my complet guide to rendering, DOM parity, the most-restrictive-directive rule, infinite scroll, and the two-pages-as-one problem. Ce article is the condensed, source-linked version.
• The Beginner’s Guide to SEO technique — où JavaScript SEO fits in the bigger picture.

My speaking

• How Search Fonctionne (SlideShare) — my walkthrough of exploration, rendering, indexation, and ranking. (My standing disclaimer s’applique: “This is my understanding of systems… not going to be 100% complete or accurate.”)

From others

• r/TechSEO — the community pour debugging render/index problems.
• web.dev — Rendering on the Web — the canonical explainer of rendering trade-offs from the Chrome team.
• Recherche Google Central — JavaScript SEO — official primary-source docs on the three-phase traiter, crawlable liens, and testing rendered HTML.
• Onely — JavaScript SEO hub — deep technical posts on rendering, two-waves indexation, and JS SEO auditing from a specialist agency.
• Martin Splitt’s JavaScript SEO playlist — the official Google video series walking via chaque JS SEO concept, produced by Google’s web ecosystem team.
• Moteur de recherche Journal — JavaScript SEO coverage — industry news and practitioner guides on JS rendering problèmes as ils emerge.

Podcasts

• Search Off the Record (Recherche Google Relations) — Martin Splitt, John Mueller, and Gary Illyes regularly cover JavaScript SEO and rendering from the à l’intérieur. Listen

Videos

• Recherche Google Central (YouTube) — Martin Splitt’s JavaScript SEO series is the meilleur official video walkthrough of how Google handles votre JS. Channel

Stats worth citing

• Current official framing: aucun fixed delay. Google’s propre documentation (mis à jour 2026-03-04) dit a crawled 200 page “may stay on ce queue pour a few seconds, but it peut prendre plus long que que” — there’s aucun publié fixed delay or timeout, and pages que retourner a non-200 status or commencer out with noindex may skip rendering entirely. Jump to quote
• Historical données point (dated) — ~5 second median render delay. In précédent conference remarks, Google staff (Martin Splitt and Tom Greenaway) décrit pages reaching the renderer at a median of ~5 seconds, with the 90th percentile in minutes — pas the “weeks” the old fear implied. I cite ce in my JavaScript SEO guide. Treat it as a historical données point from que talk, pas a current publié metric — Google hasn’t republished it as an ongoing figure, and the queue-timing quote ci-dessus is the current official framing.
• “Two waves of indexing” is fading, per Martin Splitt (2019 remarks). In an August 2019 conversation with John Mueller, Splitt said two-wave indexation “play[s] moins and moins of a role” as rendering obtient cheaper and exploration, rendering, and indexation converge — with aucun timeline donné pour quand it pourrait arrêter entirely. Coverage Ce is Splitt’s characterization from que spécifique conversation, pas a dated, citable Google spec — utiliser it as directional context, pas a current guarantee soit façon.

Google processes JavaScript apps via exploration, rendering, and indexation. Evidence for this claim Google processes JavaScript web apps in three main phases: crawling, rendering, and indexing; without rendering, Google might not see JavaScript-provided content. Scope: Google Search's processing of JavaScript pages; successful rendering does not guarantee indexing or ranking. Confidence: high · Verified: 2026-07-14 Google Search Central: Understand the JavaScript SEO basics It généralement crawls liens quand ils are anchors with href attributes. Evidence for this claim Google can reliably discover links only when they are HTML anchor elements with an href attribute. Scope: Link discovery by Google Search; this does not claim that every discovered URL will be crawled or indexed. Confidence: high · Verified: 2026-07-14 Google Search Central: Make your links crawlable Google describes rendu côté serveur or pre-rendering as a bon idea pour utilisateurs and robots d’exploration. Evidence for this claim Google describes server-side rendering or pre-rendering as a good idea because it makes a website faster for users and crawlers. Scope: Google Search guidance for JavaScript sites; the source does not prescribe one framework or guarantee indexing. Confidence: high · Verified: 2026-07-14 Google Search Central: Understand the JavaScript SEO basics Recherche Google aussi ne fait pas interact with une page to trigger content. Evidence for this claim Google Search does not interact with a page, so lazy-loaded content should load when it becomes visible in the viewport rather than requiring user interaction. Scope: Google Search's documented rendering behavior for lazy-loaded content; other crawlers can behave differently. Confidence: high · Verified: 2026-07-14 Google Search Central: Fix lazy-loaded content

Journal des modifications