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 :

1. Audit SERP — interroge une API (SerpAPI, DataForSEO) pour récupérer les 10 premiers résultats sur un mot-clé cible.
2. Analyse concurrents — scrape les pages classées, extrait structure H1/H2, longueur, densité sémantique.
3. Génération de brief — construit un brief structuré (angle, plan, mots-clés secondaires, longueur cible) à partir des données collectées.
4. 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.

Workflow complet pas à pas

Entrée : mot-clé cible
         │
         ▼
[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.

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 (comptez 50–150 € pour 100 articles).

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.