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.
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 :
import type { MetadataRoute } from "next";
export default function robots(): MetadataRoute.Robots {
return {
rules: { userAgent: "*", allow: "/" },
sitemap: "https://exemple.fr/sitemap.xml",
};
}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.
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") etIntersectionObserverfonctionnent ; un écouteur descrollne se déclenche pas toujours. - ne garde aucun état d'une page à l'autre : cookies,
localStorageetsessionStoragerepartent vides à chaque page. - refuse les autorisations : géolocalisation, notifications, caméra.
- ne suit que les liens
<a href>. Undivdont leonClickappellerouter.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.
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.
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.
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é
- Trois étapes, trois échecs possibles : explorer, rendre, indexer.
robots.txtbloque l'exploration, pas l'indexation ; unnoindexdoit rester lisible.- Le contenu et les liens du HTML brut sont lus au premier passage ; le reste attend la file de rendu.
- Googlebot ne clique pas, ne garde rien, et ne suit que les
<a href>. - Une page, une adresse : des redirections permanentes, puis
rel="canonical"déclarée page par page — jamais dans le layout racine. - Les données structurées en JSON-LD, avec
<échappé. - On vérifie dans la Search Console, pas à l'intuition.