← Retour aux tutoriels

Sujet à définir : guide SEO en français (niveau intermédiaire)

seometadatafrancaismarketing-digitalcontenu-web

Sujet à définir : guide SEO en français (niveau intermédiaire)

Ce tutoriel est un guide SEO (Search Engine Optimization) en français, destiné à un niveau intermédiaire : vous connaissez déjà les bases (balises title, meta description, notion de mots-clés, sitemap), et vous voulez passer à une approche plus systématique, mesurable et “production-ready”.

L’objectif : vous donner une méthode répétable pour auditer, corriger et améliorer un site, avec des explications approfondies et des commandes réelles (curl, grep, awk, Python, Lighthouse, etc.).

1) Pré-requis et état d’esprit “SEO technique + contenu + popularité”

Le SEO moderne repose sur trois piliers qui interagissent :

  1. Technique : indexabilité, performance, rendu, architecture, données structurées, logs.
  2. Contenu : intention de recherche, profondeur, maillage interne, E-E-A-T (expérience, expertise, autorité, fiabilité).
  3. Popularité : liens entrants (backlinks), mentions, signaux de marque.

Un audit intermédiaire doit mesurer (données), prioriser (impact/effort), et déployer (process) plutôt que “faire au feeling”.

2) Installer une boîte à outils (CLI) pour auditer vite

2.1 Outils recommandés

2.2 Installation (Debian/Ubuntu)

sudo apt update
sudo apt install -y curl wget jq ripgrep python3 python3-pip
npm install -g lighthouse

Vérification :

curl --version
jq --version
lighthouse --version
python3 --version

3) Indexabilité : vérifier que Google peut crawler et indexer

Avant d’optimiser, assurez-vous que le site est accessible, rendu correctement et autorisée à l’indexation.

3.1 Vérifier les codes HTTP et redirections

Testez une page clé :

curl -I https://example.com/

Points à vérifier :

Suivre les redirections :

curl -IL https://example.com/

Interprétation :

3.2 Contrôler robots.txt

Récupérer :

curl -s https://example.com/robots.txt

À surveiller :

Exemple correct :

User-agent: *
Disallow: /admin/
Disallow: /panier/
Sitemap: https://example.com/sitemap.xml

3.3 Balises meta robots et X-Robots-Tag

Une page peut être crawlable mais non indexable si elle contient :

Vérifier les headers :

curl -I https://example.com/page/

Cherchez X-Robots-Tag. Pour la meta robots, récupérez le HTML :

curl -s https://example.com/page/ | rg -n "meta name=\"robots\"|noindex|nofollow"

3.4 Canonical : éviter la duplication et guider l’indexation

Le canonical indique l’URL “préférée” :

<link rel="canonical" href="https://example.com/page/" />

Erreurs fréquentes :

Extraction rapide :

curl -s https://example.com/page/ | rg -n "rel=\"canonical\""

4) Architecture et maillage interne : distribuer l’autorité et faciliter le crawl

Google découvre et priorise via les liens internes. Une architecture SEO vise :

4.1 Diagnostiquer la profondeur (méthode simple)

Sans crawler avancé, vous pouvez déjà analyser un export de liens depuis un crawl (Screaming Frog) ou via wget.

Exemple de mini-crawl (limité) :

wget --mirror --convert-links --adjust-extension --page-requisites --no-parent \
  --domains example.com --level=2 --accept html \
  https://example.com/

Puis rechercher des liens vers une section :

rg -n "href=\"/produits/" -S .

Limites : wget ne rend pas le JS. Pour des sites JS, préférez un crawler qui exécute le rendu (Screaming Frog en mode rendu JS, ou Playwright).

4.2 Gérer facettes et filtres (risque de “crawl trap”)

Les filtres e-commerce génèrent des combinaisons infinies :

Stratégies :

5) Contenu : intention de recherche, profondeur, et “qualité démontrable”

5.1 Comprendre l’intention (informative, navigationnelle, transactionnelle)

Une même requête peut cacher des intentions différentes. Exemple :

Votre page doit correspondre au format que Google favorise sur la SERP :

5.2 Construire un plan sémantique (clusters)

Approche “topic cluster” :

Astuce : analyser les titres Hn et questions.

5.3 Balises Title et H1 : différencier et optimiser

Bonnes pratiques :

Extraction de title/H1 via curl + python (simple parsing regex, imparfait mais utile) :

python3 - <<'PY'
import re, sys, requests
url="https://example.com/"
html=requests.get(url, timeout=10).text
title=re.search(r"<title>(.*?)</title>", html, re.I|re.S)
h1=re.search(r"<h1[^>]*>(.*?)</h1>", html, re.I|re.S)
print("TITLE:", re.sub(r"\s+", " ", title.group(1)).strip() if title else "N/A")
print("H1   :", re.sub(r"\s+", " ", h1.group(1)).strip() if h1 else "N/A")
PY

Installez requests si nécessaire :

pip3 install requests

5.4 Contenu “utile” : signaux concrets

Au-delà du nombre de mots, Google valorise :

Évitez :

6) Données structurées (Schema.org) : enrichir l’interprétation

Les données structurées aident les moteurs à comprendre le type de contenu (Article, Product, FAQPage, BreadcrumbList…).

6.1 Exemple Product (JSON-LD)

<script type="application/ld+json">
{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Chaussures de running X",
  "image": ["https://example.com/img/x.jpg"],
  "description": "Chaussures légères pour route, amorti renforcé.",
  "sku": "RUN-X-42",
  "brand": { "@type": "Brand", "name": "MarqueX" },
  "offers": {
    "@type": "Offer",
    "url": "https://example.com/produit/chaussures-x/",
    "priceCurrency": "EUR",
    "price": "129.90",
    "availability": "https://schema.org/InStock"
  }
}
</script>

Points d’attention :

6.2 Tester via l’inspection HTML

Extraction JSON-LD :

curl -s https://example.com/produit/chaussures-x/ | rg -n "application/ld\+json" -n

Pour extraire le bloc (approche rapide) :

curl -s https://example.com/produit/chaussures-x/ \
 | python3 - <<'PY'
import re,sys
html=sys.stdin.read()
m=re.findall(r'<script[^>]+application/ld\+json[^>]*>(.*?)</script>', html, re.S|re.I)
print("Blocs JSON-LD:", len(m))
for i,block in enumerate(m,1):
    print("\n--- Bloc", i, "---\n")
    print(block.strip()[:2000])
PY

7) Performance web (Core Web Vitals) : SEO et conversion

Les Core Web Vitals (CWV) sont des métriques centrées utilisateur :

7.1 Audit Lighthouse en CLI

lighthouse https://example.com/ \
  --only-categories=performance,seo,accessibility \
  --output html --output-path ./rapport-lighthouse.html

Pour un audit mobile (par défaut Lighthouse simule mobile, mais vous pouvez préciser) :

lighthouse https://example.com/ --preset=perf --form-factor=mobile --output json --output-path ./lh.json

Lire des champs clés avec jq :

jq '.audits["largest-contentful-paint"].displayValue,
    .audits["cumulative-layout-shift"].displayValue,
    .audits["interactive"].displayValue' lh.json

7.2 Optimisations fréquentes (avec explications)

Vérifier compression :

curl -I -H 'Accept-Encoding: br,gzip' https://example.com/ | rg -n "content-encoding|content-type|cache-control"

8) International et multilingue : hreflang (si concerné)

Si vous avez plusieurs langues/pays, hreflang évite la cannibalisation et sert la bonne version.

Exemple :

<link rel="alternate" hreflang="fr-FR" href="https://example.com/fr/page/" />
<link rel="alternate" hreflang="fr-CA" href="https://example.com/ca-fr/page/" />
<link rel="alternate" hreflang="en-US" href="https://example.com/en/page/" />
<link rel="alternate" hreflang="x-default" href="https://example.com/page/" />

Règles :

9) Logs serveur : comprendre le crawl réel (niveau intermédiaire/avancé)

Les outils SEO montrent une vue “théorique”. Les logs montrent la réalité : quelles URL Googlebot visite, à quelle fréquence, et avec quels codes.

9.1 Exemple d’analyse rapide (format Apache/Nginx)

Supposons un fichier access.log. Extraire Googlebot (simpliste, user-agent spoofable, mais utile) :

rg -i "googlebot" access.log > googlebot.log

Compter les hits par code HTTP :

awk '{print $9}' googlebot.log | sort | uniq -c | sort -nr

Lister les URL les plus crawlées :

awk '{print $7}' googlebot.log | sort | uniq -c | sort -nr | head -n 30

Détecter des 404 crawlées :

awk '$9 ~ /^404$/ {print $7}' googlebot.log | sort | uniq -c | sort -nr | head -n 50

Interprétation :

10) Sitemaps XML : qualité > quantité

Un sitemap aide à la découverte, mais ne garantit pas l’indexation.

Bon sitemap :

10.1 Vérifier un sitemap

Télécharger :

curl -s https://example.com/sitemap.xml -o sitemap.xml
head -n 20 sitemap.xml

Extraire les URL :

rg -o "https?://[^<]+" sitemap.xml | head

Tester un échantillon d’URL (codes HTTP) :

rg -o "https?://[^<]+" sitemap.xml | head -n 50 > urls.txt

while read -r url; do
  code=$(curl -s -o /dev/null -w "%{http_code}" -L "$url")
  echo "$code $url"
done < urls.txt | sort | uniq -c

Si vous voyez beaucoup de 301, votre sitemap contient des URL non finales : corrigez à la source.

11) Migration et refonte : éviter la catastrophe SEO

Une refonte est un projet SEO critique. Les points incontournables :

  1. Mapping d’URL : ancienne → nouvelle
  2. Redirections 301 : propres, 1 saut
  3. Conserver le contenu qui ranke (ou l’améliorer)
  4. Vérifier canonicals, hreflang, sitemaps
  5. Monitorer : Search Console, logs, positions, trafic

11.1 Générer un fichier de redirections (exemple)

Supposons un CSV mapping.csv :

old_url,new_url
/ancienne-page/,/nouvelle-page/
/blog/abc/,/guides/abc/

Créer des règles Nginx :

python3 - <<'PY'
import csv
with open("mapping.csv") as f:
    r=csv.DictReader(f)
    for row in r:
        old=row["old_url"].strip()
        new=row["new_url"].strip()
        print(f"rewrite ^{old}$ {new} permanent;")
PY

Pour Apache .htaccess :

python3 - <<'PY'
import csv
with open("mapping.csv") as f:
    r=csv.DictReader(f)
    for row in r:
        old=row["old_url"].strip().lstrip("/")
        new=row["new_url"].strip()
        print(f"Redirect 301 /{old} {new}")
PY

Testez ensuite un lot d’anciennes URL :

cat old_urls.txt | head -n 50 | while read -r url; do
  echo "== $url =="
  curl -IL "https://example.com$url" | rg -n "HTTP/|location:"
done

12) Stratégie de liens (netlinking) : propre, progressive, mesurable

À niveau intermédiaire, l’enjeu est de réduire le risque et d’augmenter la pertinence.

12.1 Principes

12.2 Mesurer l’impact

Mesurez :

13) Priorisation : matrice Impact / Effort

Pour passer de l’audit à l’action, classez vos tâches :

Exemple de backlog SEO :

SujetSymptômeActionEffortImpact
Redirections en chaîne301→302→200Simplifier en 301 directMoyenFort
Sitemap avec 301URLs non finalesRegénérer sitemapFaibleMoyen
Facettes indexéespages dupliquéescanonical + noindex cibléFortFort
LCP élevéimages lourdesAVIF + dimensions + preloadMoyenFort

14) Checklist opérationnelle (à répéter chaque mois)

14.1 Technique

14.2 Contenu

14.3 Popularité

15) Mini-cas pratique : audit express d’une URL

Prenons une URL et faisons un audit rapide “intermédiaire” en 10 minutes.

15.1 Vérifier HTTP + redirections

curl -IL https://example.com/page/ | rg -n "HTTP/|location:"

15.2 Vérifier indexabilité (robots/noindex/canonical)

curl -I https://example.com/page/ | rg -n "x-robots-tag|cache-control|content-type"
curl -s https://example.com/page/ | rg -n "noindex|nofollow|rel=\"canonical\""

15.3 Vérifier title/h1 et cohérence sémantique

python3 - <<'PY'
import re, requests
url="https://example.com/page/"
html=requests.get(url, timeout=10).text
def grab(p):
    m=re.search(p, html, re.I|re.S)
    return re.sub(r"\s+"," ", m.group(1)).strip() if m else "N/A"
print("Title:", grab(r"<title>(.*?)</title>"))
print("H1:", grab(r"<h1[^>]*>(.*?)</h1>"))
PY

15.4 Audit Lighthouse rapide

lighthouse https://example.com/page/ --only-categories=performance,seo --output html --output-path ./page.html

Ensuite, ouvrez page.html et notez 3 actions concrètes (ex. images, JS, meta, liens).

16) Conclusion : votre “système” SEO intermédiaire

À ce niveau, la différence se fait sur :

Si vous voulez, donnez-moi :

et je peux proposer une checklist ciblée + une priorisation adaptée à votre cas.

Tutoriels associés

Comment analyser et optimiser vos données avec pandas Comment lancer vos premières apps avec Docker facilement Comment utiliser CSS Flexbox pour un design responsive