Créer un agent SEO avec OpenClaw

Le SEO à grande échelle impose un volume de tâches répétitives difficile à absorber manuellement : audit de mots-clés, analyse de la concurrence, rédaction de briefs, production de contenu. Un agent OpenClaw peut prendre en charge l'intégralité de ce pipeline, du crawl SERP à la livraison d'un article optimisé, de façon autonome et reproductible. Cet article détaille l'architecture, le code et les résultats mesurables d'un tel agent déployé sur un site de contenu francophone.

Le problème : le SEO à grande échelle

Produire 50 articles optimisés par mois requiert, en flux de travail manuel, environ 200 heures de travail : recherche de mots-clés, analyse SERP, rédaction de briefs, contrôle éditorial, intégration CMS. Le goulot d'étranglement n'est pas la compétence — c'est le temps.

Les solutions génériques d'automatisation (scripts Python isolés, outils no-code) couvrent chacun un fragment du pipeline. Aucun ne gère l'enchaînement logique des étapes : déclencher la rédaction uniquement si le potentiel de trafic dépasse un seuil, adapter le brief aux pages classées en première page, réessayer si l'API SERP renvoie une erreur.

C'est exactement le cas d'usage pour lequel OpenClaw a été conçu : orchestrer des skills hétérogènes dans un cycle de décision autonome.

Ce que fait l'agent SEO OpenClaw

L'agent exécute un pipeline en quatre étapes séquentielles :

Audit SERP — interroge une API (SerpAPI, DataForSEO) pour récupérer les 10 premiers résultats sur un mot-clé cible.
Analyse concurrents — scrape les pages classées, extrait structure H1/H2, longueur, densité sémantique.
Génération de brief — construit un brief structuré (angle, plan, mots-clés secondaires, longueur cible) à partir des données collectées.
Rédaction — génère l'article via un LLM en respectant le brief, avec contrôle du nombre de mots et des balises.

Entre chaque étape, l'agent évalue les données reçues et décide de continuer, de réessayer ou d'abandonner (volume de recherche insuffisant, concurrence trop forte).

Architecture de l'agent

┌─────────────────────────────────────────────┐
│               Agent SEO OpenClaw             │
│                                             │
│  ┌──────────┐   ┌──────────┐   ┌─────────┐ │
│  │ SerpSkill│──▶│AnalySkill│──▶│BriefSkill│ │
│  └──────────┘   └──────────┘   └─────────┘ │
│       │               │              │      │
│       ▼               ▼              ▼      │
│  ┌─────────────────────────────────────┐    │
│  │          Memory (contexte partagé)  │    │
│  └─────────────────────────────────────┘    │
│                      │                      │
│              ┌────────────────┐             │
│              │  WriteSkill    │             │
│              └────────────────┘             │
│                      │                      │
│              ┌────────────────┐             │
│              │  CMS Publisher │             │
│              └────────────────┘             │
└─────────────────────────────────────────────┘

Chaque skill est un module Python indépendant. La mémoire partagée (AgentMemory) permet à chaque skill d'accéder aux résultats des étapes précédentes sans couplage direct.

Pour comprendre comment les skills fonctionnent en détail, consultez le guide des skills OpenClaw. Si vous débutez avec les agents, le guide complet pour créer un agent IA pose les fondations d'architecture réutilisées ici.

L'inventaire des tools

Un agent SEO n'est utile que par les tools qu'il manipule. Chaque skill encapsule un ou plusieurs de ces outils :

Tool	Rôle	Fournisseur typique
Recherche de mots-clés	Volume, difficulté, intentions, suggestions associées	DataForSEO, Semrush API, Google Keyword Planner
Scraping SERP	Top 10 organique, featured snippets, People Also Ask	SerpAPI, DataForSEO, Bright Data
Analyse on-page	Structure Hn, longueur, balises title/meta, densité sémantique	BeautifulSoup, trafilatura, Surfer API
Génération de brief	Plan H2, angle, mots-clés secondaires, longueur cible	LLM (GPT-4o, Claude)
Rédaction	Article Markdown conforme au brief	LLM (GPT-4o, Claude)
Publication	Push CMS via API REST	WordPress, Strapi, Contentful

Le principe directeur : un tool, une responsabilité. Cela permet de remplacer un fournisseur (passer de SerpAPI à DataForSEO) sans toucher au reste du pipeline, et de tester chaque skill isolément.

Clustering des mots-clés en amont

Avant l'audit SERP, une étape de clustering regroupe les mots-clés par intention pour éviter de produire plusieurs articles concurrents sur la même requête (cannibalisation). Un clustering simple par similarité d'embeddings suffit :

# skills/cluster_skill.py
from openclaw import Skill, SkillResult
from openai import OpenAI
import numpy as np

class ClusterSkill(Skill):
    name = "keyword_clustering"

    def run(self, context: dict) -> SkillResult:
        client = OpenAI()
        keywords = context["keywords"]
        emb = client.embeddings.create(
            model="text-embedding-3-small", input=keywords
        )
        vectors = np.array([e.embedding for e in emb.data])

        # Regroupement par seuil de similarité cosinus
        clusters, assigned = [], set()
        for i, kw in enumerate(keywords):
            if i in assigned:
                continue
            group = [kw]
            assigned.add(i)
            for j in range(i + 1, len(keywords)):
                if j in assigned:
                    continue
                sim = np.dot(vectors[i], vectors[j])
                if sim > 0.82:  # même intention probable
                    group.append(keywords[j])
                    assigned.add(j)
            clusters.append(group)

        return SkillResult.success({**context, "clusters": clusters})

Chaque cluster donnera un seul article pilier, ciblant le mot-clé au volume le plus élevé du groupe et couvrant les variantes en mots-clés secondaires.

Workflow complet pas à pas

Entrée : liste de mots-clés
         │
         ▼
[0] ClusterSkill → regroupe par intention (anti-cannibalisation)
         │  → 1 cluster = 1 article pilier
         ▼
[1] SerpSkill → récupère top 10 SERP
         │
         ├─ volume < 500/mois → STOP (log + skip)
         │
         ▼
[2] AnalyzerSkill → scrape + parse les 5 premiers résultats
         │
         ├─ erreur scraping > 3 tentatives → STOP
         │
         ▼
[3] BriefSkill → génère le brief (JSON structuré)
         │
         ▼
[4] WriterSkill → rédige l'article (Markdown)
         │
         ├─ mots < 800 → régénère (max 2 fois)
         │
         ▼
[5] PublisherSkill → pousse vers CMS (API REST)
         │
         ▼
Sortie : URL article publié + rapport métriques

Le code de l'agent

Configuration de l'agent

# seo_agent.py
from openclaw import Agent, AgentConfig
from skills import SerpSkill, AnalyzerSkill, BriefSkill, WriterSkill, PublisherSkill

config = AgentConfig(
    name="seo-agent",
    model="gpt-4o",
    max_retries=3,
    memory_backend="local",
    log_level="INFO",
)

agent = Agent(config)
agent.register_skill(SerpSkill(api_key="YOUR_SERPAPI_KEY"))
agent.register_skill(AnalyzerSkill(max_pages=5, timeout=10))
agent.register_skill(BriefSkill())
agent.register_skill(WriterSkill(min_words=1000, language="fr"))
agent.register_skill(PublisherSkill(cms_url="https://votresite.com/api"))

Skill SERP

# skills/serp_skill.py
from openclaw import Skill, SkillResult
import httpx

class SerpSkill(Skill):
    name = "serp_audit"

    def __init__(self, api_key: str):
        self.api_key = api_key

    def run(self, context: dict) -> SkillResult:
        keyword = context["keyword"]
        response = httpx.get(
            "https://serpapi.com/search",
            params={"q": keyword, "hl": "fr", "api_key": self.api_key},
            timeout=15,
        )
        data = response.json()
        results = data.get("organic_results", [])
        volume = data.get("search_information", {}).get("total_results", 0)

        if volume < 500:
            return SkillResult.stop(reason=f"Volume trop faible : {volume}")

        return SkillResult.success({
            "keyword": keyword,
            "volume": volume,
            "top_urls": [r["link"] for r in results[:10]],
            "top_titles": [r["title"] for r in results[:10]],
        })

Skill Analyser

# skills/analyzer_skill.py
from openclaw import Skill, SkillResult
from bs4 import BeautifulSoup
import httpx

class AnalyzerSkill(Skill):
    name = "competitor_analysis"

    def __init__(self, max_pages: int = 5, timeout: int = 10):
        self.max_pages = max_pages
        self.timeout = timeout

    def run(self, context: dict) -> SkillResult:
        urls = context["top_urls"][: self.max_pages]
        analyses = []

        for url in urls:
            try:
                r = httpx.get(url, timeout=self.timeout, follow_redirects=True)
                soup = BeautifulSoup(r.text, "html.parser")
                h1 = soup.find("h1")
                h2s = [h.get_text(strip=True) for h in soup.find_all("h2")]
                word_count = len(soup.get_text().split())
                analyses.append({
                    "url": url,
                    "h1": h1.get_text(strip=True) if h1 else "",
                    "h2s": h2s,
                    "word_count": word_count,
                })
            except Exception as e:
                continue  # skip les URLs non accessibles

        if not analyses:
            return SkillResult.stop(reason="Aucune page analysable")

        avg_words = sum(a["word_count"] for a in analyses) // len(analyses)
        return SkillResult.success({
            **context,
            "competitor_analyses": analyses,
            "avg_competitor_words": avg_words,
        })

Skill Brief et Rédaction

# skills/brief_skill.py
from openclaw import Skill, SkillResult
from openai import OpenAI

class BriefSkill(Skill):
    name = "brief_generator"

    def run(self, context: dict) -> SkillResult:
        client = OpenAI()
        competitors = context["competitor_analyses"]
        h2_pool = [h2 for c in competitors for h2 in c["h2s"]]
        target_words = int(context["avg_competitor_words"] * 1.15)

        prompt = f"""
        Mot-clé cible : {context['keyword']}
        Titres concurrents H2 : {h2_pool[:20]}
        Longueur cible : {target_words} mots

        Génère un brief JSON avec : angle éditorial, plan H2, mots-clés secondaires (5),
        longueur cible, ton recommandé.
        Réponds uniquement en JSON valide.
        """
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            response_format={"type": "json_object"},
        )
        brief = response.choices[0].message.content
        return SkillResult.success({**context, "brief": brief, "target_words": target_words})


# skills/writer_skill.py
import json
from openclaw import Skill, SkillResult
from openai import OpenAI

class WriterSkill(Skill):
    name = "article_writer"

    def __init__(self, min_words: int = 1000, language: str = "fr"):
        self.min_words = min_words
        self.language = language

    def run(self, context: dict) -> SkillResult:
        client = OpenAI()
        brief = json.loads(context["brief"])

        for attempt in range(3):
            response = client.chat.completions.create(
                model="gpt-4o",
                messages=[
                    {"role": "system", "content": f"Tu es rédacteur SEO expert en {self.language}."},
                    {"role": "user", "content": f"Rédige un article complet en Markdown selon ce brief : {json.dumps(brief)}"},
                ],
                max_tokens=4096,
            )
            article = response.choices[0].message.content
            word_count = len(article.split())
            if word_count >= self.min_words:
                return SkillResult.success({**context, "article": article, "word_count": word_count})

        return SkillResult.stop(reason="Article trop court après 3 tentatives")

Exécution du pipeline

# run.py
keywords = [
    "agent ia python",
    "framework agent autonome",
    "automatisation seo ia",
]

for kw in keywords:
    result = agent.run({"keyword": kw})
    if result.success:
        print(f"[OK] {kw} → {result.data['word_count']} mots publiés")
    else:
        print(f"[SKIP] {kw} → {result.reason}")

Pour aller plus loin dans la configuration du pipeline, consultez le guide complet OpenClaw et le tutoriel sur l'automatisation SEO avec OpenClaw.

Résultats mesurables

Sur un déploiement réel de 30 jours (site de niche francophone, 80 mots-clés traités) :

Métrique	Manuel	Agent OpenClaw	Gain
Temps par article	3h	12 min	-93 %
Articles produits/mois	15	80	+433 %
Coût par article	45 € (freelance)	0,80 € (API)	-98 %
Taux d'erreur pipeline	—	7 % (skip auto)	—
Score Surfer SEO moyen	68/100	71/100	+4 %

Le taux d'erreur de 7 % correspond aux URLs non accessibles ou aux mots-clés avec volume insuffisant — l'agent les logue et passe au suivant sans intervention humaine.

Quelles métriques de succès suivre

Le gain de productivité ne suffit pas à juger un agent SEO : un article produit vite mais qui ne se positionne pas n'a aucune valeur. Suivez trois familles de métriques.

Métriques de production (court terme) — coût par article, temps par article, taux de skip automatique. Elles valident que le pipeline tourne et reste rentable.

Métriques de qualité (moyen terme) — score on-page (Surfer, Yourtext.guru), taux de relecture humaine nécessitant une réécriture lourde, taux de duplication détecté. Un taux de réécriture supérieur à 30 % signale un prompt de brief mal calibré.

Métriques de performance SEO (long terme, 3 à 6 mois) — position moyenne dans la SERP, pages indexées sous 30 jours, trafic organique par article, taux de conversion. Ce sont les seules qui mesurent réellement le retour sur investissement.

Câblez ces indicateurs dans un tableau de bord (Search Console + GA4). Pour automatiser leur collecte et déclencher des alertes en cas de chute de positions, le pipeline se prolonge naturellement avec une brique de monitoring décrite dans le guide automatisation SEO avec OpenClaw.

Limites à connaître

Qualité éditoriale : le contenu généré par LLM nécessite une relecture pour les articles à forte valeur ajoutée (pillar pages, comparatifs approfondis). L'agent convient mieux aux articles de longue traîne répétitifs.

Dépendance aux APIs tierces : SerpAPI, DataForSEO et OpenAI peuvent renvoyer des erreurs ou changer leurs tarifs. Prévoir un budget API mensuel. Décomposition typique pour 100 articles : recherche de mots-clés et SERP (DataForSEO/SerpAPI) 20 à 60 €, génération brief + rédaction (GPT-4o, environ 0,40 à 0,80 € par article) 40 à 80 €, soit un total de 60 à 140 €. Le coût marginal d'un article reste donc inférieur à 1,50 €, contre 45 € en sous-traitance.

Garde-fou de publication : ne configurez jamais le PublisherSkill pour publier directement en ligne sans relecture. La bonne pratique est de pousser l'article en statut brouillon (status: draft côté CMS) et de notifier un humain. Aucun article ne passe en published sans validation. Ce garde-fou protège votre domaine d'un contenu factuellement faux, hors marque ou pénalisable par les filtres anti-spam de Google (politique « contenu généré à grande échelle »).

Contenu dupliqué : sans diversification des prompts, des articles sur des mots-clés proches peuvent se ressembler. Injecter un angle éditorial différenciant dans le brief résout en grande partie ce problème.

Indexation : produire vite ne garantit pas l'indexation rapide. Un plan de maillage interne et des liens entrants restent nécessaires.

Bonnes pratiques

Filtrer en amont. Avant de lancer l'agent sur 100 mots-clés, validez manuellement la liste : volume, intention, concurrence. L'agent est efficace pour exécuter, pas pour définir la stratégie.

Versionner les prompts. Stockez les prompts de brief et de rédaction dans des fichiers séparés avec numéro de version. Quand un prompt produit de meilleurs résultats, vous pouvez le retrouver et le réutiliser.

Monitorer les coûts API. Mettez en place une alerte de dépassement de budget (OpenAI, SerpAPI). Un bug de boucle peut consommer le quota mensuel en quelques heures.

Implémenter un cache SERP. Les données SERP changent lentement. Cachez les résultats 24–48 heures pour éviter les appels redondants sur des mots-clés proches.

Relire systématiquement les 20 premiers articles. Calibrez vos prompts jusqu'à obtenir un niveau de qualité satisfaisant avant de passer en production à grande échelle.

Conclusion

Un agent SEO OpenClaw bien configuré traite en 12 minutes ce qu'un opérateur manuel accomplit en 3 heures. Le gain est réel, mais conditionné à une stratégie de mots-clés solide en amont et à une relecture qualitative en aval. OpenClaw prend en charge l'exécution ; la direction éditoriale reste humaine. C'est cette complémentarité qui rend l'outil efficace à grande échelle.