← Retour aux tutoriels

Guide SEO en français : optimiser vos pages pour mieux se positionner

seoréférencement natureloptimisation on-pagemots-clésmaillage interne

Guide SEO en français : optimiser vos pages pour mieux se positionner

Le SEO (Search Engine Optimization) regroupe l’ensemble des techniques visant à améliorer la visibilité d’un site dans les résultats des moteurs de recherche (Google, Bing, etc.). L’objectif n’est pas seulement “d’être premier”, mais surtout d’attirer le bon trafic (qualifié), de répondre à l’intention de recherche, et de convertir (vente, prise de contact, inscription…).

Ce tutoriel est un guide complet et pratique (avec des commandes réelles) pour optimiser vos pages : technique, contenu, maillage interne, performance, données structurées, et suivi.

Sommaire

  1. Comprendre comment Google évalue une page
  2. Recherche de mots-clés et intention de recherche
  3. Optimisation on-page : balises, structure, sémantique
  4. Contenu : profondeur, E-E-A-T et qualité
  5. SEO technique : indexation, crawl, canonicals, robots.txt
  6. Performance web : Core Web Vitals, images, cache
  7. Maillage interne et architecture
  8. Données structurées (Schema.org)
  9. Backlinks : stratégie et précautions
  10. Mesure et monitoring : Search Console, logs, audits
  11. Checklist finale

Comprendre comment Google évalue une page

Avant d’optimiser, il faut comprendre les grandes étapes :

  1. Découverte : Google trouve vos URL via des liens, un sitemap, ou des requêtes directes.
  2. Crawl : Googlebot visite les pages et télécharge les ressources (HTML, CSS, JS, images).
  3. Rendu : Google peut exécuter une partie du JavaScript pour comprendre le contenu final.
  4. Indexation : la page est stockée (ou non) dans l’index.
  5. Classement : lors d’une recherche, Google choisit quelles pages afficher et dans quel ordre.

Facteurs majeurs (simplifiés)

Le point crucial : le SEO est un système. Une optimisation isolée (ex. “ajouter un mot-clé”) n’est pas suffisante si la page est lente, non indexable, ou si l’intention n’est pas respectée.

Recherche de mots-clés et intention de recherche

1) Partir des besoins réels

Un “mot-clé” représente souvent un besoin. Exemple :

2) Construire un univers sémantique

Au lieu de viser un seul terme, visez un cluster :

3) Extraire des idées avec des commandes (pratique)

Vous pouvez récupérer des suggestions depuis vos propres données (logs, Search Console export) ou via des pages existantes.

Extraire des titres (SERP-like) depuis votre site

Si vous avez une liste d’URL, vous pouvez récupérer les <title> :

# urls.txt contient une URL par ligne
while read -r url; do
  echo "== $url =="
  curl -sL "$url" | pup 'title text{}'
done < urls.txt

pup est un parseur HTML en ligne de commande. Installation (macOS) : brew install pup. Sur Linux, selon la distribution.

Analyser rapidement des occurrences dans un texte

Utile pour vérifier si vous couvrez un champ lexical :

curl -sL "https://exemple.com/ma-page" \
  | lynx -stdin -dump -nolist \
  | tr '[:upper:]' '[:lower:]' \
  | grep -Eo '\b(trail|imperméable|gore-tex|semelle|drop)\b' \
  | sort | uniq -c | sort -nr

4) Cartographier les pages (éviter la cannibalisation)

La cannibalisation survient quand plusieurs pages ciblent la même intention/mot-clé, se concurrencent, et affaiblissent le classement.

Créez un tableau :

Optimisation on-page : balises, structure, sémantique

1) Balise Title

Le <title> influence fortement le taux de clic (CTR) et la pertinence.

Bonnes pratiques :

Exemple :

Vérifier les titles en masse (crawl simple)

Si vous avez un sitemap :

curl -sL https://exemple.com/sitemap.xml \
  | grep -oE '<loc>[^<]+' | sed 's/<loc>//' > urls.txt

while read -r url; do
  title=$(curl -sL "$url" | pup 'title text{}')
  echo -e "$url\t$title"
done < urls.txt > titles.tsv

2) Meta description

Elle n’est pas un facteur direct de ranking, mais influence le CTR.

3) H1, H2, H3 : structure logique

Exemple de structure :

4) URL et fil d’Ariane

5) Images : SEO + accessibilité

Conversion en WebP (commande réelle) :

cwebp -q 80 input.jpg -o output.webp

Conversion en AVIF (souvent meilleur ratio) :

avifenc --min 20 --max 30 input.jpg output.avif

6) Liens sortants et internes

Contenu : profondeur, E-E-A-T et qualité

Google évalue la qualité via de nombreux signaux. Le concept E-E-A-T (Experience, Expertise, Authoritativeness, Trustworthiness) est particulièrement important pour certains domaines (YMYL : santé, finance, juridique).

1) Répondre à l’intention de recherche

Pour une requête “comment choisir …”, une page produit purement commerciale ne suffit pas. Il faut :

2) Créer une page “meilleure que la moyenne”

Concrètement :

3) Éviter le “fluff”

Un texte long n’est pas automatiquement bon. La profondeur doit être utile :

4) Signaux de confiance

SEO technique : indexation, crawl, canonicals, robots.txt

1) Vérifier l’indexation

Tapez dans Google : site:exemple.com (indication approximative). Pour du sérieux : Google Search Console.

2) Robots.txt

Le fichier https://exemple.com/robots.txt indique ce que vous autorisez/interdisez au crawl.

Exemple prudent :

User-agent: *
Disallow: /admin/
Disallow: /panier/
Disallow: /compte/
Allow: /

Sitemap: https://exemple.com/sitemap.xml

Attention :

3) Meta robots et X-Robots-Tag

Dans le HTML :

<meta name="robots" content="index,follow">

Pour bloquer :

<meta name="robots" content="noindex,follow">

Pour des PDFs ou ressources non-HTML, utilisez l’en-tête HTTP X-Robots-Tag.

Tester les en-têtes :

curl -I https://exemple.com/document.pdf

4) Canonical

Le canonical indique l’URL “référence” quand il y a des duplications (paramètres, tri, pagination…).

Dans le <head> :

<link rel="canonical" href="https://exemple.com/trail/chaussures-impermeables/">

Vérifier le canonical :

curl -sL https://exemple.com/page | pup 'link[rel="canonical"] attr{href}'

5) Sitemap XML

Un sitemap aide la découverte des URL importantes.

Exemple minimal :

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://exemple.com/</loc>
    <lastmod>2026-03-01</lastmod>
  </url>
</urlset>

Vérifier qu’il est accessible :

curl -sI https://exemple.com/sitemap.xml | head

6) Codes HTTP et erreurs

Lister les codes HTTP d’une liste d’URL :

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

7) JavaScript et rendu

Si votre contenu principal est injecté en JS, Google peut avoir du retard ou des difficultés à indexer correctement.

Test rapide : comparer HTML brut vs rendu (avec un outil headless). Exemple avec Playwright (Node.js) :

npm init -y
npm i playwright
node - <<'NODE'
const { chromium } = require('playwright');
(async () => {
  const browser = await chromium.launch();
  const page = await browser.newPage();
  await page.goto('https://exemple.com', { waitUntil: 'networkidle' });
  const content = await page.content();
  console.log(content.slice(0, 2000));
  await browser.close();
})();
NODE

Si le contenu important n’apparaît pas dans curl mais apparaît après rendu, vous dépendez fortement du JS : à optimiser (SSR, pré-rendu, hydratation, etc.).

Performance web : Core Web Vitals, images, cache

Les Core Web Vitals principaux :

1) Mesurer avec Lighthouse (commande)

Avec Chrome installé :

npx lighthouse https://exemple.com \
  --output html \
  --output-path ./lighthouse-report.html

Ouvrez ensuite lighthouse-report.html.

2) Optimiser les images (pratique)

Exemple HTML :

<img
  src="/images/chaussures-800.webp"
  srcset="/images/chaussures-400.webp 400w, /images/chaussures-800.webp 800w, /images/chaussures-1200.webp 1200w"
  sizes="(max-width: 600px) 400px, (max-width: 900px) 800px, 1200px"
  width="1200"
  height="800"
  alt="Chaussures de trail imperméables sur terrain humide"
  loading="lazy"
>

3) Compression et cache côté serveur

Vérifier la compression :

curl -sI -H "Accept-Encoding: gzip, br" https://exemple.com/ | grep -i content-encoding

Vérifier le cache :

curl -sI https://exemple.com/ | grep -iE 'cache-control|etag|last-modified'

Bonnes pratiques :

Maillage interne et architecture

Le maillage interne sert à :

1) Architecture en silo / clusters

Exemple :

La page hub (catégorie/guide) fait des liens vers les pages filles, et inversement.

2) Ancres de lien

3) Détecter des pages orphelines (approche simple)

Si vous pouvez exporter la liste des URL et extraire les liens internes depuis un crawl, vous pouvez comparer.

Exemple très simplifié (indicatif) : extraire les liens d’une page

curl -sL https://exemple.com/ | pup 'a attr{href}' | head

Pour un audit complet, utilisez un crawler (Screaming Frog, Sitebulb) ou un script dédié.

Données structurées (Schema.org)

Les données structurées aident les moteurs à comprendre le contenu (et parfois à afficher des résultats enrichis).

1) Article / BlogPosting

Exemple JSON-LD :

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Chaussures de trail imperméables : guide + sélection 2026",
  "author": {
    "@type": "Person",
    "name": "Camille Dupont"
  },
  "datePublished": "2026-03-01",
  "dateModified": "2026-03-10",
  "mainEntityOfPage": "https://exemple.com/trail/chaussures-impermeables/"
}
</script>

2) FAQPage (si vous avez une vraie FAQ)

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Les chaussures de trail Gore-Tex sont-elles respirantes ?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Elles offrent une bonne protection contre l'eau, mais la respirabilité dépend du modèle, de la température et de l'intensité."
      }
    }
  ]
}
</script>

3) Tester votre balisage

Google propose des outils de test (Rich Results Test). Côté ligne de commande, vous pouvez au moins vérifier la présence du script :

curl -sL https://exemple.com/page | grep -n "application/ld+json" -n

Backlinks : stratégie et précautions

Les liens entrants restent un levier important, mais il faut privilégier la qualité.

1) Stratégies “propres”

2) Éviter les risques

3) Linkbait utile (exemples)

Mesure et monitoring : Search Console, logs, audits

Sans mesure, vous optimisez à l’aveugle.

1) Google Search Console (GSC)

Indispensable pour :

Routine recommandée (hebdomadaire) :

2) Analyse de logs serveur (avancé mais puissant)

Les logs montrent :

Exemple : extraire les hits Googlebot (format dépend du serveur)

grep -i "Googlebot" /var/log/nginx/access.log | tail -n 50

Compter les URLs les plus crawlées par Googlebot (exemple simplifié) :

grep -i "Googlebot" /var/log/nginx/access.log \
  | awk '{print $7}' \
  | sort | uniq -c | sort -nr | head -n 30

3) Audits automatisés (contrôles rapides)

Vérifier que des pages importantes renvoient bien 200 :

printf "%s\n" \
  "https://exemple.com/" \
  "https://exemple.com/trail/" \
  "https://exemple.com/trail/chaussures-impermeables/" \
| while read -r url; do
  code=$(curl -s -o /dev/null -w "%{http_code}" -L "$url")
  echo "$code $url"
done

Checklist finale

Contenu & intention

On-page

Technique

Performance

Autorité & popularité

Suivi

Conclusion

Optimiser vos pages pour mieux se positionner demande une approche méthodique : intention + contenu + technique + performance + popularité + mesure. Commencez par sécuriser l’indexation et la performance, puis travaillez la profondeur du contenu et le maillage interne, avant d’investir dans des actions d’acquisition de liens.

Si vous me donnez votre type de site (blog, e-commerce, SaaS), votre CMS (WordPress, Shopify, headless…), et 3–5 URL importantes, je peux proposer un plan d’optimisation priorisé (quick wins + chantiers structurants) et des commandes adaptées à votre contexte.

Tutoriels associés

Analyse de données avec Pandas en Python : guide intermédiaire Bien démarrer avec Docker : guide pour débutants Comprendre CSS Flexbox pour un design responsive