ETag et 304 en SEO : tester la revalidation d’une page

Tester ETag, Last-Modified et les réponses 304 avec un serveur Python local, puis vérifier compression, variantes et cache public sans masquer une mise à jour.

Une question mène à une réponse reliée à sa page source et à une preuve accessible.

Pour vérifier une configuration ETag et 304 en SEO, demandez d’abord la page entière, conservez son validateur, puis renvoyez ce validateur dans une requête conditionnelle. La représentation inchangée doit pouvoir produire une réponse 304 sans corps. Après modification, l’ancien ETag doit permettre de récupérer la nouvelle représentation en 200. Afficher simplement un en-tête ETag ne suffit pas à démontrer cette chaîne.

Ce protocole s’adresse au responsable technique ou SEO qui doit réceptionner un changement de cache. Il commence par un laboratoire Python entièrement local, puis transforme les résultats en fiche de contrôle pour un hébergement réel. Le travail attendu consiste à vérifier que le serveur économise un transfert quand cela convient et livre bien une modification lorsqu’elle existe.

Réponse en bref

Un ETag identifie une version de représentation. Le client le renvoie dans If-None-Match pour demander une comparaison. Sur une lecture conditionnelle, la correspondance permet une réponse 304 ; une version différente demande de livrer le document actuel. Last-Modified et If-Modified-Since offrent une autre comparaison, fondée sur une date. Quand les deux conditions sont présentes, If-None-Match prime.

La recette doit donc couvrir les deux directions : conserver une copie valable et remplacer une copie dépassée. Ajoutez une variante compressée, car comparer le bon contenu dans le mauvais encodage peut révéler un validateur mal construit. Vérifiez également les métadonnées de la réponse 304, particulièrement ETag et Vary, au lieu de compter seulement son nombre d’octets.

Une réponse 304 ne constitue pas un levier de classement. Elle communique une décision de revalidation. Pour terminer ce guide, préparez une fiche contenant une URL publique, les en-têtes envoyés, les en-têtes reçus, le statut, le nombre d’octets du corps et la version attendue. Vous disposerez alors d’un résultat que l’équipe peut reproduire.

Séparer le document stocké de la réponse qui le valide

Imaginez une notice publique déjà téléchargée. Le lecteur possède son texte ; il souhaite savoir si cette copie reste utilisable. Une revalidation réussie évite de transmettre ce texte une nouvelle fois. La réponse courte n’est donc pas une nouvelle notice vide : elle se rapporte à une représentation que le client détient déjà.

Le guide MDN des requêtes conditionnelles décrit cette logique de comparaison. Une requête initiale et une requête conditionnelle n’ont pas le même rôle. Gardez les deux dans votre preuve : sans téléchargement initial, il manque la copie à laquelle le validateur se rapporte.

Cela explique aussi un piège de réception. Un outil peut afficher le document reconstruit depuis son cache, tandis que l’échange réseau comporte un 304. Pour examiner le transfert, observez la requête et la réponse HTTP. Pour examiner ce que le lecteur voit, observez son navigateur. Notre laboratoire utilise un client qui affiche directement les octets reçus et ne reconstitue aucun document.

Situer l’intérêt SEO sans lui attribuer un résultat automatique

La documentation des crawlers Google indique la prise en charge des couples ETag/If-None-Match et Last-Modified/If-Modified-Since. Elle recommande ETag pour éviter les difficultés de format des dates. L’usage effectif du cache dépend néanmoins du crawler et du produit concerné.

Google décrit le 304 comme l’indication que le contenu est identique à celui de la visite précédente. Sa documentation des statuts HTTP précise que ce statut n’a, par lui-même, pas d’effet sur l’indexation. Une bonne recette HTTP ne permet donc pas de conclure qu’une URL sera mieux positionnée ou plus rapidement réexplorée.

Le guide du budget d’exploration relie la réutilisation d’une copie aux ressources et à la bande passante du serveur. Son contexte principal reste celui des grands sites ou des contenus très changeants. Pour une petite publication, commencez par une livraison correcte et une découverte cohérente. La date de révision éditoriale répond à une autre question : ce que l’auteur a effectivement revu dans le contenu.

Définir les résultats attendus avant de tester

La table suivante décrit notre notice fictive. Aucune ligne ne mesure Googlebot. Le serveur et le client de l’exercice sont tous deux sous notre contrôle, ce qui permet de connaître la version attendue avant l’échange.

Situation construiteCondition envoyéeRésultat attendu
Première lectureAucune200, document entier
Copie encore valableETag courant304, corps vide
Copie dépasséeAncien ETag200, nouveau document
Date seule encore valableLast-Modified courant304, corps vide
Date favorable mais ETag dépasséLes deux conditions200, ETag prioritaire
Date ancienne mais ETag courantLes deux conditions304, ETag prioritaire
Même variante gzipETag de cette variante304, corps vide
ETag non compressé envoyé pour gzipValidateur d’une autre variante200, octets gzip

Les règles de priorité et l’absence de corps d’un 304 sont définies dans la RFC 9110. Dans cet exercice, une lecture sans condition reste une réponse 200, même si le client vient de demander exactement la même page. Le serveur ne déduit pas l’existence d’une copie à partir de l’adresse du client ou de son nom de navigateur.

Exécuter treize échanges HTTP sur son ordinateur

Le programme suivant utilise Python 3.9 ou plus récent et sa bibliothèque standard. Enregistrez-le dans recette_etag.py, puis lancez python3 recette_etag.py. Il ouvre un port disponible sur l’interface locale, effectue les requêtes, vérifie les réponses et ferme le serveur. Il ne contacte aucun hébergement externe et ne modifie aucun fichier du site.

Les deux notices et leurs dates sont des données pédagogiques fixes. Le changement de version intervient en mémoire. Le calcul de l’ETag porte sur les octets effectivement servis ; gzip utilise un horodatage fixe pour rester déterministe. La négociation est volontairement limitée aux valeurs exactes identity et gzip, suffisantes pour cette recette.

import gzip
import hashlib
import http.client
import re
from email.utils import formatdate, parsedate_to_datetime
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from threading import Thread

versions = [
    (b"<p>Notice version A</p>\n", 1792404000),
    (b"<p>Notice version B corrigee</p>\n", 1792490400),
]
state = {"version": 0}


class Handler(BaseHTTPRequestHandler):
    def log_message(self, *args):
        pass

    def do_GET(self):
        if self.path != "/notice":
            self.send_error(404)
            return
        body, modified = versions[state["version"]]
        coding = self.headers.get("Accept-Encoding", "identity")
        if coding not in {"identity", "gzip"}:
            self.send_error(406)
            return
        if coding == "gzip":
            body = gzip.compress(body, mtime=0)
        etag = '"' + hashlib.sha256(body).hexdigest() + '"'
        incoming = self.headers.get("If-None-Match")
        if incoming is not None:
            tags = re.findall(r'(?:W/)?"[^"]*"', incoming)
            unchanged = incoming.strip() == "*" or any(
                tag.removeprefix("W/") == etag for tag in tags
            )
        else:
            try:
                since = parsedate_to_datetime(
                    self.headers.get("If-Modified-Since", "")
                ).timestamp()
                unchanged = modified <= since
            except (ValueError, TypeError, OverflowError):
                unchanged = False
        self.send_response(304 if unchanged else 200)
        self.send_header("ETag", etag)
        self.send_header("Last-Modified", formatdate(modified, usegmt=True))
        self.send_header("Vary", "Accept-Encoding")
        self.send_header("Cache-Control", "public, no-cache")
        if not unchanged:
            self.send_header("Content-Type", "text/html; charset=utf-8")
            self.send_header("Content-Length", str(len(body)))
            if coding == "gzip":
                self.send_header("Content-Encoding", "gzip")
        self.end_headers()
        if not unchanged:
            self.wfile.write(body)


server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
thread = Thread(target=server.serve_forever, daemon=True)
thread.start()


def fetch(label, expected, headers=None):
    connection = http.client.HTTPConnection(*server.server_address, timeout=3)
    request_headers = {"Accept-Encoding": "identity", **(headers or {})}
    connection.request("GET", "/notice", headers=request_headers)
    response = connection.getresponse()
    body = response.read()
    meta = dict(response.getheaders())
    connection.close()
    assert response.status == expected, (label, response.status)
    assert meta["Vary"] == "Accept-Encoding"
    assert (body == b"") if expected == 304 else bool(body)
    print(label, response.status, len(body))
    return meta, body


try:
    first, body_a = fetch("initial", 200)
    old = first["ETag"]
    date_a = first["Last-Modified"]
    fetch("identique", 304, {"If-None-Match": old})
    fetch("faible", 304, {"If-None-Match": "W/" + old})
    fetch("date_identique", 304, {"If-Modified-Since": date_a})
    fetch("etag_prioritaire_200", 200, {
        "If-None-Match": '"perime"', "If-Modified-Since": date_a
    })
    state["version"] = 1
    changed, body_b = fetch("modifie", 200, {"If-None-Match": old})
    assert body_b != body_a and changed["ETag"] != old
    fetch("etag_ancien_date_courante", 200, {
        "If-None-Match": old,
        "If-Modified-Since": changed["Last-Modified"]
    })
    fetch("date_ancienne", 200, {"If-Modified-Since": date_a})
    fetch("etag_prioritaire_304", 304, {
        "If-None-Match": changed["ETag"], "If-Modified-Since": date_a
    })
    zipped, wire = fetch("gzip_initial", 200, {"Accept-Encoding": "gzip"})
    assert gzip.decompress(wire) == body_b
    assert zipped["ETag"] != changed["ETag"]
    fetch("gzip_identique", 304, {
        "Accept-Encoding": "gzip", "If-None-Match": zipped["ETag"]
    })
    fetch("mauvaise_variante", 200, {
        "Accept-Encoding": "gzip", "If-None-Match": changed["ETag"]
    })
    fetch("sans_condition", 200)
finally:
    server.shutdown()
    server.server_close()
    thread.join(timeout=2)

Le serveur accepte ici une seule route de lecture. Son extraction des validateurs couvre les valeurs créées pour l’exercice, y compris leur préfixe faible ; elle ne remplace pas le parseur d’un serveur HTTP de production. Conservez votre serveur existant et ses bibliothèques pour l’implémentation réelle. Le programme sert à comprendre un contrat et à vérifier ses contre-exemples.

Lire les résultats sans confondre corps et échange complet

L’exécution effectuée pour ce guide produit treize lignes. La première lecture transfère 24 octets de corps. La revalidation identique en reçoit zéro. Après le passage à la notice B, le client reçoit 33 octets et un autre ETag. Ces tailles appartiennent uniquement à la petite fixture : elles ne décrivent ni une page réelle ni un gain moyen.

Deux lignes rendent la priorité observable. etag_ancien_date_courante reçoit la version B en 200 malgré une date qui, seule, autoriserait une revalidation. etag_prioritaire_304 reçoit un 304 malgré une date ancienne, puisque son ETag correspond déjà à B. Tester seulement le cas où les deux conditions sont d’accord laisserait passer une mauvaise priorité.

La ligne faible vérifie qu’un préfixe W/ ne bloque pas cette comparaison de lecture. La documentation ETag de MDN distingue validateurs forts et faibles. Le préfixe décrit la nature de l’équivalence ; il ne remplace pas la nécessité de changer le validateur lorsque la représentation pertinente change.

Enfin, zéro octet de corps ne signifie pas zéro trafic. Les en-têtes et l’échange réseau existent toujours. Notre compteur ignore aussi le coût du calcul côté serveur. Il serait donc incorrect de convertir les chiffres du laboratoire en pourcentage d’économie d’infrastructure ou en gain d’exploration.

Vérifier les variantes avant d’adopter un ETag commun

Dans la fixture, la notice B non compressée contient 33 octets ; sa variante gzip en contient 53. Une compression peut grossir un minuscule document à cause de son enveloppe. Ce résultat n’évalue pas l’intérêt de gzip pour des pages normales. Il fournit simplement deux représentations différentes dont nous pouvons vérifier les validateurs.

Le test exige que leur décodage donne le même texte tout en leur attribuant deux ETag forts différents. La dernière requête gzip avec le validateur non compressé reçoit donc un nouveau corps. Un cache ne doit pas récupérer des octets compressés en supposant détenir déjà cette représentation précise.

L’en-tête Vary: Accept-Encoding accompagne les succès et les revalidations de notre serveur. La documentation Vary explique son rôle dans la séparation des réponses selon les en-têtes ayant influencé leur sélection. Sur une architecture réelle, contrôlez qui compresse, qui calcule le validateur et qui ajoute Vary. Ces trois responsabilités peuvent appartenir à des couches différentes.

Si un réseau de diffusion de contenu, ou CDN, transforme la réponse après l’origine, répétez la recette au point d’entrée public. Un test direct de l’origine peut réussir alors que le visiteur reçoit d’autres octets et d’autres en-têtes. Faites documenter le traitement du validateur par cette couche avant de considérer le contrôle comme terminé.

Préparer une recette sur un hébergement réel

Choisissez d’abord une ressource publique de test dont le contenu peut être modifié sur une préproduction autorisée. Évitez une page très personnalisée, une session connectée ou une ressource réglementaire sensible. Notez le chemin final après redirection afin de comparer la même URL et la même variante pendant toute la séquence.

Demandez une première copie sans condition et conservez son corps séparément des en-têtes. Répétez avec If-None-Match en gardant les guillemets du validateur reçu. Recommencez sans condition. Cette troisième lecture confirme que le serveur continue à livrer le document entier à quelqu’un qui ne présente pas de copie.

Effectuez ensuite une modification contrôlée du texte sur cet environnement. Rejouez l’ancien ETag et comparez le nouveau corps attendu. Le critère de réussite est concret : la phrase changée doit figurer dans les octets reçus. Voir un 200 sans comparer les documents laisserait passer une ancienne copie renvoyée par un cache intermédiaire.

Ajoutez les deux combinaisons contradictoires de date et d’ETag de notre table. Puis répétez la séquence avec les encodages réellement proposés par votre hébergement. Conservez les réponses du point d’entrée public et, si l’équipe y a accès, celles de l’origine. La différence permet de désigner une couche à examiner sans désactiver tout le cache au hasard.

Un audit SEO et GEO peut intégrer cette fiche à la réception technique. Pour une application qui génère elle-même ses pages, le travail d’automatisation Python peut conserver les mêmes cas dans une vérification récurrente. Leur intérêt consiste à détecter une régression précise, avec un résultat attendu que le développeur peut reproduire.

Diagnostiquer les deux défauts les plus coûteux à confondre

Un ETag qui change à chaque lecture rend la comparaison inutile pour une représentation pourtant stable. Cherchez un horodatage de génération, un identifiant aléatoire ou une personnalisation dans la sortie. Comparez les corps avant de corriger le validateur : s’ils diffèrent réellement, il faut comprendre pourquoi le serveur produit ces variantes.

À l’inverse, un ETag constant après modification peut maintenir une ancienne copie. Un calcul fondé uniquement sur une date éditoriale ou une version applicative trop large peut manquer une variation du document. Ajoutez au contrôle une modification courte mais décisive, par exemple le remplacement d’une phrase, puis vérifiez qu’elle traverse toute la chaîne.

Le même raisonnement s’applique à Last-Modified. L’heure d’une compilation n’est pas automatiquement la dernière modification pertinente de chaque représentation. Une date trop grossière peut aussi rendre deux changements indiscernables. Notez la méthode utilisée par votre système au lieu de supposer que ce champ reflète exactement l’historique du rédacteur.

Si les octets reçus sont corrects mais que le navigateur n’affiche pas le contenu attendu, poursuivez avec le protocole de rendu JavaScript. Si la ressource a été retirée, appliquez une décision de retrait adaptée. La revalidation suppose que vous cherchez toujours à servir cette ressource.

Décider séparément du stockage public et des données personnelles

La fixture émet Cache-Control: public, no-cache. Dans le vocabulaire de la RFC 9111, no-cache impose une validation avant réutilisation ; il n’interdit pas le stockage. no-store interdit ce stockage par les caches concernés, tandis que private exclut le stockage par un cache partagé. Ces directives expriment des politiques différentes.

Ces règles de cache HTTP ne fixent pas le calendrier de Googlebot. La documentation Google limite la prise en charge décrite pour ses crawlers aux mécanismes de validation présentés plus haut. Définir une durée de cache pour un navigateur ne revient donc pas à programmer la prochaine exploration d’une URL.

N’appliquez donc pas la politique publique du laboratoire à un espace client. Avant de parler de validateurs, classez les réponses selon leur contenu : information commune à tous, personnalisation sans donnée sensible, ou document associé à une personne. Déterminez qui peut conserver la réponse et quelle couche décide de cette autorisation.

Une variante linguistique et une facture individuelle ne posent pas le même problème de distribution. Ajouter Vary ne constitue pas, à lui seul, une politique de confidentialité. Notre serveur n’implémente ni authentification ni espace privé ; la bonne politique dépend de l’application. Gardez les réponses personnalisées hors de cette recette publique tant que leur traitement n’a pas été défini.

Rédiger une fiche que l’équipe peut accepter ou refuser

Pour chaque cas, consignez l’URL finale, l’environnement, la version de contenu attendue, l’encodage demandé et les conditions envoyées. Ajoutez le statut, l’ETag, Last-Modified, Vary, la politique de cache et le nombre d’octets du corps reçus. Conservez aussi une empreinte du document lorsque cela permet de comparer deux exécutions sans diffuser son texte.

La décision peut tenir en une phrase : « version A encore valable, corps non retransmis » ou « version B attendue, ancien validateur remplacé, nouveau texte reçu ». Une anomalie reçoit un propriétaire technique et un cas reproductible. Évitez une note globale de cache qui masquerait une erreur sur un document particulier.

Sur l’hébergement réel, mesurez ensuite les transferts et les temps avec un périmètre stable. Comparez des visites conditionnelles comparables, en distinguant origine et CDN. L’exécution locale établit les comportements de notre fixture ; les journaux de votre environnement établissent ce qui s’y produit. Ni l’un ni l’autre ne remplace l’observation du traitement d’une URL par Google.

Limites

Ce laboratoire ne simule pas un navigateur complet, un proxy, un CDN ou les décisions d’un crawler. Il ne traite que des lectures GET d’une notice publique et deux encodages simples. Un hébergement réel peut ajouter des variantes, des transformations, des politiques de stockage et des règles d’authentification qui demandent leurs propres contrôles.

Un validateur correct porte sur la représentation sélectionnée. Il ne démontre ni la qualité de l’article, ni sa révision éditoriale, ni son indexation. Après une modification d’architecture, de compression ou de personnalisation, rejouez la recette au point d’entrée réellement utilisé : un ancien résultat local ne valide pas cette nouvelle chaîne.

Historique des mises à jour

Le 21 octobre 2026 : publication du serveur local, des treize échanges vérifiés et de la fiche de réception pour une revalidation HTTP correcte.

Sources vérifiées

Rechercher

La recherche porte uniquement sur les contenus publiés. Entrée ouvre le premier résultat ; les flèches permettent de choisir.