JavaScript SEO : les bonnes pratiques pour rendre votre site crawlable

  • Entreprises & e-commerce

    Un accompagnement SEO sur mesure par nos experts

    Audit, stratégie, rédaction et netlinking : on prend en main votre référencement de A à Z pour transformer votre visibilité en clients.

  • Équipes SEO & agences

    Des backlinks de qualité, en toute autonomie

    Accédez à notre réseau de 50 000+ sites vérifiés et commandez vos liens en self-service, sans abonnement ni volume minimum.

  • Avant de vous lancer

    Un audit SEO complet de votre site

    On identifie vos freins techniques, vos opportunités de mots-clés et le gap avec vos concurrents, avec un plan d'action chiffré.

Par Jédirfort H.Publié le Mis à jour le 16 min de lecture

Il existe une version de votre site que vous n’avez jamais vue : celle que les robots lisent. Du HTML nu, souvent sans votre texte et vos liens. Le contenu SEO n’apparaît qu’après, lorsque le JavaScript s’exécute dans le navigateur. Googlebot de Google repasse plus tard pour le voir, parfois des jours après sa première visite. Mais, les crawlers des IA (LLM) ou des réseaux sociaux, eux, ne feront pas ce deuxième passage.

Votre page peut donc être parfaite pour vos lecteurs tout en restant difficile à exploiter pour certains robots, sans que vous vous en rendiez compte. Vous trouvez ça flou ? Faites le test : clic droit, « Afficher le code source », puis recherchez votre premier paragraphe. S’il n’apparaît pas dans le HTML initial, votre contenu dépend de JavaScript pour être chargé. Thriix vous présente les bonnes pratiques pour faciliter l’exploration et l’indexation de vos contenus.

JavaScript SEO : de quoi parle-t-on vraiment ?

Développeurs et référenceurs SEO emploient le terme sans y mettre la même chose. Le premier y voit une contrainte sur son framework ; le second, des pages qui n’apparaissent pas dans les résultats. La définition qui suit les réconcilie.

Le JavaScript SEO est l’ensemble des pratiques qui rendent explorable et indexable, par les robots des moteurs de recherche, un site dont le contenu ou la navigation dépend de JavaScript. La discipline se situe à l’intersection du développement front-end et du référencement technique.

Tout repose sur une distinction que votre navigateur vous cache. Quand il demande une page, le serveur lui renvoie un fichier texte, le HTML source, aussi appelé HTML initial : c’est la version brute, celle que vous lisez avec « Afficher le code source ». Le navigateur exécute ensuite les scripts, qui ajoutent des blocs de texte ou des liens. Le résultat, le DOM rendu, est ce que vous voyez à l’écran. Sur une application React ou Vue, le HTML source se réduit parfois à une coquille vide, tandis que tout le contenu utile n’existe que dans le DOM rendu.

Rien, dans ce mécanisme, n’accuse le JavaScript lui-même : une page bâtie avec un framework moderne peut se positionner aussi bien qu’une page en HTML statique. La question porte sur le bot, ce programme qui visite vos pages pour le compte du moteur : a-t-il les moyens d’exécuter votre code ? Certains robots s’arrêtent au HTML source ; Googlebot le fait, mais en différé. Le JavaScript SEO consiste à diminuer cet écart, pour que la version reçue par le robot contienne déjà les éléments qui comptent pour votre référencement.

Comment Google traite-t-il réellement une page JavaScript ?

Googlebot ne lit pas votre page en une seule fois. Il la traite en trois temps, séparés par des délais que vous ne maîtrisez pas.

  1. Crawl : Googlebot demande l’URL, reçoit le HTML source et y relève les liens qu’il peut lire immédiatement.

  2. File de rendu : la page rejoint la file d’attente du Web Rendering Service, un Chromium sans écran qui exécute le JavaScript quand des ressources se libèrent.

  3. Indexation : le DOM rendu remplace la version brute, et Google indexe le contenu complet, liens injectés compris.

Entre la première et la troisième étape s’ouvre l’écart que les référenceurs appellent la deuxième vague (two-wave indexing). Lors de la première vague, Google indexe le contenu du HTML source, et rien de ce que le script ajoute. Lors de la deuxième, après rendu, le contenu injecté rejoint l’index et les liens découverts dans le DOM entrent dans la file de crawl. Une page dont tout le texte dépend du JavaScript vit donc une existence incomplète entre les deux.

Le délai de rendu et son impact sur la fraîcheur du contenu indexé

Il n’existe pas de délai standard appliqué à tous. Le rendu coûte cher en calcul et Google le planifie selon les ressources disponibles ainsi que l’importance qu’il accorde à votre site. Une page d’accueil très visitée passe vite dans la file, une fiche produit profonde peut y patienter plusieurs jours.

Les conséquences se voient sur les contenus SEO qui changent souvent : un prix mis à jour côté client ou une rupture de stock affichée par un script attendent le prochain passage du moteur de rendu. Si votre modèle économique dépend de cette fraîcheur, le contenu concerné doit figurer dans le HTML source, pour être indexé dès la première vague par Google et les autres.

Ce que voient les autres bots (Bing, LLM crawlers, réseaux sociaux)

Bingbot exécute le JavaScript de façon limitée et sans garantie de délai. Les robots des modèles de langage, ceux qui alimentent les assistants conversationnels, lisent le HTML source et s’arrêtent là. Votre page n’existe pour eux que sous sa forme brute. Les robots des réseaux sociaux, qui construisent l’aperçu d’un lien partagé, se comportent de la même manière et cherchent vos balises Open Graph dans le HTML initial.

Aucune deuxième vague ne viendra pour ces robots, contrairement à Google. Si votre objectif est de positionner votre site dans les réponses générées par IA ou d’obtenir un aperçu impeccable quand l’un de vos liens circule sur LinkedIn, servez votre contenu SEO directement dans le HTML source. L’argument est nouveau dans la discussion avec vos développeurs et il pèse davantage à chaque arbitrage technique.

CSR, SSR, SSG : choisir le mode de rendu selon ce qui est critique pour le ranking

Où le HTML est-il produit ? Dans le navigateur du visiteur, sur votre serveur à chaque requête, ou une fois pour toutes au déploiement. Le bon choix dépend du contenu à indexer plutôt que des habitudes de votre équipe technique.

Le rendu côté client (CSR) : liberté maximale, risque d’indexation élevé

En CSR (client-side rendering), le serveur envoie une page presque vide et un paquet JavaScript que le navigateur exécute pour construire le DOM. C’est le fonctionnement par défaut d’une application React, Vue ou Angular créée avec les outils standard. L’expérience est fluide une fois le chargement terminé pour le visiteur. Pour le robot, le HTML source ne contient ni texte ni liens : tout attend la file de rendu et les robots sans exécution JavaScript ne verront pas le contenu.

Réservez ce mode à un espace connecté ou à un tableau de bord, des pages sans intérêt SEO et qu’aucun moteur n’a vocation à indexer. Dès qu’une page doit se positionner, il devient un pari sur la bonne volonté de Googlebot.

Le rendu côté serveur (SSR) et la génération statique (SSG) : contenu visible dès le premier octet

Avec le SSR (server-side rendering), votre serveur exécute lui-même le JavaScript à chaque requête et renvoie un HTML complet. Le robot de Google reçoit le texte comme les liens dès la première réponse. Next.js ou Nuxt proposent ce mode nativement, au prix d’une charge serveur à chaque visite et d’une mise en cache plus délicate.

La génération statique (static site generation) construit les pages une seule fois, au déploiement, puis les sert comme de simples fichiers HTML. Aucun calcul à la requête et un HTML source complet pour tous les robots. Le problème apparaît lorsque le contenu évolue très souvent. Une page qui change plusieurs fois par jour exige de reconstruire le site ou de recourir à une régénération incrémentale.

L’hydratation : quand le contenu est visible, mais absent du HTML source

L’hydratation désigne le moment où une page rendue côté serveur est reprise en main par le JavaScript dans le navigateur, pour devenir interactive. Bien menée, elle combine un HTML source complet et une application réactive. Le piège apparaît quand une partie du contenu n’est chargée qu’après l’hydratation, par un appel d’API lancé côté client.

L’utilisateur voit un bloc d’avis ou une liste de produits, alors que le HTML source ne contient qu’un emplacement vide. Le robot indexe le vide. Cette configuration est la plus difficile à repérer, parce que la page semble correcte à l’écran et que seul le code source la trahit.

Comparatif CSR, SSR et SSG selon quatre critères

Critère

CSR

SSR

SSG

Vitesse d’indexation

Lente : le contenu attend la file de rendu

Rapide : le HTML complet est indexé dès la première vague

Rapide : même HTML complet, servi depuis le cache

Complexité

Faible côté serveur, tout se passe dans le navigateur

Élevée : serveur Node, cache et gestion des erreurs à la requête

Moyenne : chaîne de build à maintenir, régénération à prévoir

Performance perçue

Écran blanc jusqu’à l’exécution du script

Contenu visible tôt, interactivité après hydratation

Affichage immédiat, interactivité après hydratation

Cas d’usage recommandé

Espaces connectés et outils internes

Catalogues et contenus qui changent souvent

Blogs et pages de service

Vous avez du mal à décider ? Suivez cette règle : si le contenu est critique pour le ranking, il doit figurer dans le HTML servi au bot, quel que soit le framework. Le texte principal et la navigation relèvent de cette catégorie, les métadonnées aussi. Un module de recommandations ou un widget de chat peuvent rester en CSR sans dommage. Le mode de rendu se choisit donc composant par composant et non une fois pour toutes à l’échelle du site.

Les pièges JavaScript qui bloquent l’indexation

Les problèmes rencontrés en audit tiennent rarement au mode de rendu global, mais à des détails d’implémentation que ni le développeur ni le visiteur ne remarquent. Même un site en SSR n’est pas à l’abri. Chacun des pièges ci-dessous se décrit par son mécanisme et par son effet sur l’indexation.

Problèmes 

Description

Fichiers JavaScript bloqués dans robots.txt : Google peut-il rendre la page ?

Une ligne Disallow sur le dossier des scripts empêche Googlebot de télécharger le code. Conséquence : le rendu échoue et la page est indexée dans sa version brute, souvent vide.

Fragments # dans les URL : Google les distingue-t-il ?

La partie après le dièse est ignorée par le robot, qui ne voit qu’une seule adresse. Conséquence : vos vues/catalogue#chaussures et/catalogue#sacs se confondent en une page unique.

Liens onclick ou href="#” : Google peut-il les suivre ?

Googlebot ne relève que les liens portés par une balise a avec un attribut href valide. Conséquence : une navigation en boutons JavaScript laisse des pages orphelines, que le robot ne découvre pas.

Soft 404 après routage côté client : la page manquante est-elle bien signalée ?

Une application monopage répond 200 à toutes les adresses, puis affiche « page introuvable » par script. Conséquence : Google indexe des pages d’erreur et gaspille son budget de crawl sur des adresses vides.

Lazy loading mal configuré : le contenu se charge-t-il pour un robot qui ne scrolle pas ?

Quand un texte ou une liste ne se charge qu’au défilement, le moteur de rendu, qui n’imite pas un utilisateur, ne le déclenche pas. Conséquence : le contenu situé sous la ligne de flottaison manque à l’index.

Canonical ou noindex injectés après rendu : quelle version Google retient-il ? 

Si le HTML source annonce une directive et que le script en écrit une autre, les deux vagues d’indexation reçoivent des consignes contradictoires. Conséquence : une page peut sortir de l’index, ou une canonical peut être ignorée, sans logique apparente.

Timeout de rendu : le script termine-t-il à temps ? 

Le Web Rendering Service accorde un temps limité à chaque page. Un appel d’API lent ou une chaîne de scripts trop longue dépasse ce délai. Conséquence : le DOM est figé à mi-chemin, avec les blocs qui n’ont pas eu le temps d’apparaître.

Ces pièges nous montrent que ce qui n’est pas livré dans le HTML brut fragilise Googlebot et condamne d’office votre visibilité sur les IA et les réseaux sociaux. Il existe toutefois des règles à appliquer pour rendre chaque page crawlable dès le premier passage.

Bonnes pratiques JavaScript SEO : rendre chaque page crawlable

Les bonnes pratiques qui suivent se rangent par couche technique, dans l’ordre où un robot les rencontre. Chacune s’énonce comme une consigne, suivie de la raison qui la justifie, pour que vous puissiez la transmettre telle quelle à votre équipe de développement.

HTML source et contenu critique : ce qui doit être présent avant le rendu

Servez le contenu principal dans le HTML initial. La première vague d’indexation ne voit que lui, et les robots sans rendu ne verront rien d’autre. Placez le titre comme le corps de texte dans la réponse du serveur. Ces éléments décident du positionnement et n’ont aucune raison d’attendre un script. Testez chaque nouveau gabarit avec « Afficher le code source » avant la mise en ligne. Si le premier paragraphe n’y figure pas, le gabarit n’est pas prêt.

Liens, canonical et directives robots : éviter les incohérences entre source et DOM

Écrivez chaque lien avec une balise a et un attribut href qui pointe vers une URL complète. Googlebot ne suit ni les onclick ni les href=”#”, et un routeur JavaScript peut tout à fait coexister avec des liens standard. Gardez les URL propres, sans fragment #. Le robot ignore la partie après le dièse, et une vue accessible uniquement par fragment n’a pas d’existence propre dans l’index.

Placez la canonical et les directives robots, noindex compris, dans le HTML source, puis n’y touchez plus côté client. C’est le principe de la parity DOM : les directives lues dans le HTML initial et celles présentes dans le DOM rendu doivent être identiques, sinon les deux vagues d’indexation se contredisent. Renvoyez un vrai code 404 pour une page absente, depuis le serveur. Une application monopage qui répond 200 puis affiche une erreur par script produit des soft 404 que Google finit par indexer. Laissez robots.txt ouvert sur vos fichiers JavaScript et CSS. Sans eux, le moteur de rendu ne reconstitue pas la page.

Données structurées et performances : les réglages qui complètent l’indexation

Injectez le JSON-LD dans le HTML source plutôt que par script. Google sait lire un balisage ajouté côté client, mais seulement après rendu, et les autres robots ne le liront pas du tout. Validez chaque gabarit avec le test des résultats enrichis, sur l’URL réelle et non sur un extrait de code collé.

Réduisez le poids des scripts et le nombre d’appels d’API nécessaires au premier affichage. Le moteur de rendu accorde un temps limité à chaque page et un script qui dépasse ce délai laisse un DOM incomplet. Chargez en différé les images sous la ligne de flottaison avec l’attribut natif loading="lazy” qu’avec un script au scroll. Le robot ne défile pas, mais il lit l’attribut natif.

  • Le contenu qui doit se positionner figure dans le HTML source.

  • Chaque lien porte une balise a avec un href complet.

  • Canonical et directives robots sont identiques dans le HTML source et dans le DOM rendu.

  • Le JSON-LD s’injecte côté serveur.

  • Les scripts et les fichiers CSS restent accessibles dans robots.txt.

Pas une de ces consignes n’exige de changer de framework. Elles portent sur l’endroit où le HTML est produit et sur la façon d’écrire un lien ou une directive. Ces décisions se prennent gabarit par gabarit et se vérifient en quelques minutes avec les outils que nous allons voir dans la section suivante.

Tester et auditer le rendu JavaScript

Pour savoir ce que Google voit réellement sur vos pages JavaScript, une seule méthode fait foi : comparer le HTML source et le DOM rendu, puis chercher les écarts. Le protocole se décline en trois étapes et ne demande aucun outil payant.

  1. Ouvrez le HTML source de la page (clic droit, « Afficher le code source », ou view-source : devant l’URL) et cherchez votre premier paragraphe et vos liens de navigation.

  2. Dans la Search Console, lancez l’inspection de l’URL, demandez un test en direct puis affichez la page testée : l’onglet HTML montre le DOM rendu tel que Googlebot l’a reconstruit.

  3. Comparez les deux versions, élément par élément : contenu, liens, canonical, balises robots. Chaque élément présent dans le DOM rendu, mais absent du HTML source dépend du JavaScript et attend la deuxième vague.

View-source vs DOM rendu : comprendre la différence

La confusion vient de l’outil « Inspecter » du navigateur. Ce panneau affiche le DOM, donc l’état de la page après exécution des scripts et il passe souvent pour le code source. Le vrai HTML source s’obtient avec view-source, qui montre la réponse brute du serveur, sans aucune exécution. Quand les deux versions se ressemblent, votre page est en SSR ou en SSG et le JavaScript ne fait qu’ajouter de l’interactivité. Quand view-source affiche une balise div vide et un script, vous êtes en CSR et tout votre référencement dépend de la file de rendu.

Les outils pour comparer ce que Googlebot voit et ce que vous voyez

Pour examiner le DOM tel que Googlebot le perçoit après avoir exécuté vos scripts, l’outil d’inspection d’URL de la Search Console reste la référence. Il vous livre la page finale, tout en signalant les ressources bloquées et les éventuelles erreurs d’exécution JavaScript.

Si vous souhaitez comprendre ce que reçoivent les robots incapables de lire le JavaScript, tournez-vous vers les Chrome DevTools. En modifiant l’agent utilisateur pour simuler Googlebot et en désactivant le JavaScript dans les paramètres, vous visualisez le code brut initialement fourni par votre serveur.

Côté performance de rendu, Lighthouse peut faire l’affaire. En mesurant le temps avant le premier affichage et en identifiant les scripts bloquants, il vous donne une indication très claire sur vos risques de timeout lors de l’exploration. De son côté, le Test des résultats enrichis de Google vous confirmera si vos données structurées survivent à la phase de rendu sur l’URL réelle.

Pour une vue d’ensemble, Screaming Frog configuré en mode rendu JavaScript est une option redoutable. Équipé de son propre navigateur Chromium, il va crawler l’intégralité de votre site et comparer, page après page, les différences exactes entre votre HTML brut et votre HTML rendu.

Checklist opérationnelle : JavaScript SEO de la mise en prod au monitoring

Cette checklist JavaScript SEO couvre le cycle complet d’un déploiement, des vérifications à faire avant la mise en ligne jusqu’à la surveillance du site en production. Elle s’adresse autant à votre équipe technique qu’à la personne chargée du référencement et elle gagne à être intégrée à votre procédure de recette plutôt qu’appliquée après coup.

Avant la mise en ligne

  1. Vérifier que robots.txt n’interdit aucun fichier JavaScript ni CSS nécessaire au rendu.

  2. Contrôler que chaque lien de navigation est une balise a avec un href complet.

  3. Comparer HTML source et DOM rendu sur un gabarit de chaque type (parity DOM).

  4. Tester les codes de statut : une page absente renvoie un 404 réel, une page déplacée un 301.

  5. Confirmer que la canonical de chaque gabarit est présente dans le HTML source et identique après rendu.

Après le déploiement

  1. Suivre le rapport Pages de la Search Console pendant les semaines qui suivent, en surveillant les statuts « Explorée, actuellement non indexée » et « Page en double ».

  2. Lancer Lighthouse sur les gabarits principaux et comparer les résultats à ceux d’avant déploiement.

  3. Lire les logs serveur pour vérifier que Googlebot télécharge bien les fichiers JavaScript et qu’il atteint les pages profondes.

Le moment où le SEO entre dans le processus fait toute la différence. Un référenceur consulté après la mise en ligne constate les dégâts. Mais consulté au moment du choix du mode de rendu et de l’écriture des gabarits, il les évite. Nous recommandons un point de contrôle à la fin de chaque sprint qui touche à un gabarit indexable, avec les cinq vérifications de la première liste comme condition de recette.

Passé le déploiement, la surveillance devient une routine : des alertes sur la couverture dans la Search Console et un crawl mensuel en mode rendu JavaScript pour repérer un lien devenu onclick ou une canonical écrasée par une mise à jour. Si vous préférez confier cette vigilance à des personnes qui la pratiquent au quotidien, notre équipe audite le rendu de vos pages et accompagne vos développeurs jusqu’à ce que chaque gabarit soit crawlable.

L'auteur

Jédirfort H.

Consultant SEO

J'écris sur le netlinking et le contenu à partir de 12 ans de terrain : des articles, des liens, puis les outils et les algorithmes de thriix. Ingénieur chercheur de formation, en sciences vétérinaires, j'applique au SEO la méthode de la recherche : hypothèses, mesures et sources. Je parle ici de la façon dont Google traite les liens et de ce que l'IA change.

Voir toutes les publications

Un accompagnement SEO sur mesure par nos experts, ça vous tente ?

Articles similaires

Aucun article à afficher.