Aller au contenu
Hugo Delacour
Tous les articles

Ce que Googlebot voit vraiment d'un site Next.js

Explorer, rendre, indexer : trois étapes, et trois façons de perdre une page sans le moindre message d'erreur. Ce que Google lit dans le HTML brut, ce qu'il attend du JavaScript, et comment une seule adresse doit l'emporter sur ses doublons — avec la Metadata API de Next.js.

28 octobre 20268 min
  • SEO
  • Next.js
  • SSR
  • Architecture

Un site peut être rapide, accessible, bien écrit — et absent de Google. Pas parce qu'il serait mal « optimisé », mais parce que l'une des trois étapes par lesquelles passe chaque page a échoué en silence : l'exploration, le rendu, l'indexation. Chacune a ses règles, et chacune se vérifie.

Explorationfile d'adressesGooglebotrobots.txtIndexDOM renduServeurHTML brutChromiumexécute le JSRendufile d'attenteGETliens
Le trajet d'une page chez Google : explorée, mise en file, rendue par un Chromium, indexée. Les liens trouvés dans le HTML brut repartent vers l'exploration dès le premier passage.

Explorer : ce que Googlebot demande

Tout commence par une adresse dans une file d'attente. Avant de la demander, Googlebot lit le robots.txt du site : si l'adresse y est interdite, il ne la demande pas. Sinon, il la télécharge et lit le HTML brut — la réponse du serveur, avant tout JavaScript. Chaque lien qu'il y trouve rejoint la file.

Le code de réponse compte autant que le contenu :

Réponse Ce que Google en fait
200 la page peut être indexée
301, 308 redirection permanente : la cible devient l'adresse à retenir
302, 307 redirection temporaire : l'adresse de départ peut rester
404, 410 la page sort de l'index
429, 500, 503 Googlebot ralentit son exploration du site
200 sur une page « introuvable » une soft 404 : repérée, et traitée comme une erreur

Deux confusions coûtent cher. robots.txt empêche l'exploration, pas l'indexation : une adresse interdite mais citée ailleurs peut apparaître dans les résultats, sans description. Et pour retirer une page de l'index, il faut une balise noindex — que Googlebot doit pouvoir lire, donc dans une page qu'il a le droit d'explorer. Bloquer une page dans robots.txt et la marquer noindex, c'est cacher la consigne à celui qui doit la lire.

Dans Next.js, les deux fichiers s'écrivent en code :

app/robots.ts
import type { MetadataRoute } from "next";
 
export default function robots(): MetadataRoute.Robots {
  return {
    rules: { userAgent: "*", allow: "/" },
    sitemap: "https://exemple.fr/sitemap.xml",
  };
}
app/sitemap.ts
import type { MetadataRoute } from "next";
import { getAllArticles } from "@/lib/articles";
 
export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  const articles = await getAllArticles();
  return articles.map((article) => ({
    url: `https://exemple.fr/articles/${article.slug}`,
    // La date du contenu, pas celle du build : une date qui change à chaque déploiement ne dit plus rien.
    lastModified: new Date(article.date),
  }));
}

Google se sert de lastModified quand il le juge fiable, et ignore priority comme changeFrequency. Un sitemap ne fait pas indexer une page : il aide Googlebot à la trouver.

Rendre : le JavaScript passe après

Une fois explorée, la page entre dans une file de rendu. Un Chromium sans écran, tenu à jour depuis 2019, l'ouvre, exécute son JavaScript, et c'est le DOM obtenu qui part à l'index. La documentation de Google le dit sans détour : une page peut rester dans cette file quelques secondes, ou plus longtemps.

1 · L'EXPLORATION LIT LE HTML BRUT2 · LA PAGE ATTEND DANS LA FILE DE RENDU3 · CHROMIUM EXÉCUTE LE JAVASCRIPTRENDU CLIENTCSR<div id="root"></div>RENDU SERVEURSSRFILE D'EXPLORATIONFILE D'EXPLORATION0 lien2 liens2 liensFILE DE RENDU : SECONDES, OU PLUSRIEN À ATTENDRE
La même page, rendue côté client puis côté serveur. À gauche, le HTML brut n'est qu'une coquille : texte et liens attendent la file de rendu. À droite, tout est dans la première réponse, et les liens partent tout de suite vers l'exploration.

Pour une page rendue côté serveur, ce délai ne retarde rien d'important : le texte et les liens étaient déjà dans la première réponse. Pour une application rendue côté client, tout attend — le contenu, et les liens vers les autres pages, que Googlebot ne découvrira qu'après le rendu.

Le rendu lui-même a ses limites. Googlebot :

  • ne clique pas, et ne fait pas défiler la page comme un humain : un contenu qui n'apparaît qu'après un clic sur « Voir plus » n'existe pas pour lui. Le chargement différé natif (loading="lazy") et IntersectionObserver fonctionnent ; un écouteur de scroll ne se déclenche pas toujours.
  • ne garde aucun état d'une page à l'autre : cookies, localStorage et sessionStorage repartent vides à chaque page.
  • refuse les autorisations : géolocalisation, notifications, caméra.
  • ne suit que les liens <a href>. Un div dont le onClick appelle router.push() n'est pas un lien.
// Invisible pour Googlebot : il n'y a aucune adresse à suivre.
<div onClick={() => router.push("/articles/ssr")}>Le SSR</div>
 
// Un lien : il est dans le HTML, avec son adresse.
<Link href="/articles/ssr">Le SSR</Link>

Le composant Link de Next.js rend un vrai <a href>, et c'est la raison la plus solide de rendre côté serveur les pages qui doivent être trouvées : le rendu serveur et le rendu statique mettent contenu et liens dans la première réponse, là où le rendu client les suspend à une file dont personne ne garantit la durée.

Indexer : une page, une adresse

Pour un lecteur, exemple.fr/articles/ssr et exemple.fr/articles/ssr?utm_source=lettre sont la même page. Pour un robot, ce sont deux adresses qui renvoient le même contenu : des doublons. Google les regroupe et en retient une, la canonique : c'est elle qui apparaît dans les résultats, et elle récolte les signaux des autres.

Il choisit sur des indices, qu'il vaut mieux rendre concordants :

  • une redirection permanente est l'indice le plus fort : l'adresse redirigée ne sera pas retenue ;
  • la balise rel="canonical" est un indice fort — un indice, pas un ordre ;
  • la présence dans le sitemap compte aussi, plus faiblement.
CINQ ADRESSES, UN SEUL CONTENUL'ADRESSE RETENUEexemple.fr/articles/ssrCANONIQUEhttp://exemple.fr/articles/ssr308 · VERS HTTPShttps://www.exemple.fr/articles/ssr308 · SANS WWWhttps://exemple.fr/articles/ssr/308 · SANS BARRE FINALEhttps://exemple.fr/articles/ssr?utm_source=xREL=CANONICALhttps://exemple.fr/articles/ssr#planFRAGMENT : MÊME ADRESSEREDIRECTION 308 : SIGNAL FORT · REL=CANONICAL : SIGNAL FORT, PAS UN ORDRE
Cinq adresses pour un seul article. Les redirections ramènent les trois premières, la balise canonique désigne la bonne pour la quatrième, et un fragment n'est pas une adresse pour Google.

Next.js règle déjà la barre finale : /articles/ssr/ répond par une redirection 308 vers /articles/ssr. Le www et le http se règlent chez l'hébergeur. Les paramètres de campagne, eux, ne se redirigent pas : c'est le rôle de la canonique, déclarée page par page avec la Metadata API.

app/articles/[slug]/page.tsx
export async function generateMetadata({ params }: PageProps<"/articles/[slug]">): Promise<Metadata> {
  const { slug } = await params;
  const article = await getArticle(slug);
  if (!article) return {};
  return {
    title: article.title,
    description: article.description,
    // Une adresse relative : le `metadataBase` du layout racine la complète.
    alternates: { canonical: `/articles/${slug}` },
  };
}

Le piège : Next.js fusionne les métadonnées des layouts et des pages en surface. Une canonique posée dans le layout racine est donc héritée par chaque page qui n'en déclare pas — et toutes désignent alors l'accueil comme leur version canonique. Il n'y a pas de façon plus rapide de faire disparaître un site entier des résultats. La canonique se déclare sur chaque page.

Deux précisions. Les chemins sont sensibles à la casse : /Articles/SSR est une autre adresse, ici une 404. Et un site en plusieurs langues ajoute alternates.languages, qui relie les versions entre elles — c'est l'objet de l'article sur l'i18n.

Dire ce qu'est la page : les données structurées

Le HTML dit ce que la page contient ; les données structurées disent ce qu'elle est : un article, son auteur, sa date. Google recommande le format JSON-LD, un script qui ne s'affiche pas.

app/articles/[slug]/page.tsx
const jsonLd = {
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  headline: article.title,
  description: article.description,
  datePublished: article.date,
  inLanguage: "fr",
  author: { "@type": "Person", name: "Hugo Delacour", url: "https://www.hugodelacour.com" },
};
 
<script
  type="application/ld+json"
  // `<` échappé : une chaîne venue du contenu ne doit pas pouvoir fermer la balise.
  dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd).replace(/</g, "\\u003c") }}
/>

Le remplacement de < n'est pas décoratif. Sans lui, un titre contenant </script> fermerait la balise et injecterait du HTML dans la page : c'est la précaution que recommande la documentation de Next.js. Le test des résultats enrichis de Google vérifie ensuite le balisage. Il ne garantit aucun affichage enrichi ; il le rend seulement possible.

Cette page porte d'ailleurs les deux : sa canonique, et un BlogPosting en JSON-LD.

Vérifier ce que Google a vu

On ne devine pas, on regarde.

  • Le HTML brut : curl -s https://exemple.fr/articles/ssr | grep "<h1" montre ce que lit l'exploration, sans JavaScript. Si le titre n'y est pas, il faudra attendre le rendu.
  • L'inspection d'URL de la Search Console : le HTML rendu par Google, une capture, les ressources bloquées, et la canonique qu'il a retenue — qui n'est pas toujours celle que tu as déclarée.
  • Le rapport « Pages » de la Search Console : ce qui est indexé, ce qui ne l'est pas, et pourquoi.
  • Les journaux du serveur : les passages de Googlebot, page par page. Son nom se falsifie facilement ; une recherche DNS inverse dit si c'est bien lui.

En résumé

  1. Trois étapes, trois échecs possibles : explorer, rendre, indexer.
  2. robots.txt bloque l'exploration, pas l'indexation ; un noindex doit rester lisible.
  3. Le contenu et les liens du HTML brut sont lus au premier passage ; le reste attend la file de rendu.
  4. Googlebot ne clique pas, ne garde rien, et ne suit que les <a href>.
  5. Une page, une adresse : des redirections permanentes, puis rel="canonical" déclarée page par page — jamais dans le layout racine.
  6. Les données structurées en JSON-LD, avec < échappé.
  7. On vérifie dans la Search Console, pas à l'intuition.