Semrush API Développeur : comment j’automatise mes workflows SEO avec l’API

L’semrush api développeur est l’outil qui me permet de travailler à une échelle impossible manuellement. Dans mes audits clients, quand un site a 50 000 pages ou qu’un client veut surveiller 2 000 mots-clés, les interfaces graphiques Semrush ont leurs limites. L’API lève ces contraintes.

Ce guide s’adresse aux consultants SEO, développeurs et growth hackers qui veulent automatiser leurs workflows Semrush via l’API REST.

L’API Semrush : vue d’ensemble technique

Architecture de l’API

Semrush propose deux types d’API :

API REST classique (la plus utilisée) :

• Format : requêtes HTTP GET avec paramètres d’URL
• Authentification : clé API unique dans les paramètres
• Réponse : CSV ou JSON selon le type de requête
• Documentation : developers.semrush.com

API Reporting :

• Accès aux données de vos projets Semrush (Position Tracking, Site Audit…)
• Format JSON
• Idéal pour l’intégration dans des dashboards BI

Modèle de crédits API

L’API Semrush fonctionne avec un système de crédits (API units) :

• Chaque requête consomme des unités selon le type de données
• Les plans Semrush incluent des crédits API (10 000 unités/jour pour le plan Pro)
• Des crédits supplémentaires sont achetables

Consommation typique :

• Recherche de 1 mot-clé (volume, KD) : 1 unité
• Analyse backlinks d’un domaine (100 résultats) : 10 unités
• Positions organiques d’un domaine (100 résultats) : 10 unités
• Traffic Analytics d’un domaine : 1 unité

Exemples pratiques en Python

Installation et configuration

import requests
import pandas as pd

API_KEY = "votre_cle_api_semrush"
BASE_URL = "https://api.semrush.com/"

def semrush_request(endpoint, params):
    params['key'] = API_KEY
    response = requests.get(BASE_URL + endpoint, params=params)
    if response.status_code == 200:
        return response.text
    else:
        raise Exception(f"Erreur API: {response.status_code}")

Exemple 1 : Récupérer les positions organiques d’un domaine

def get_domain_organic_keywords(domain, country="fr", limit=100):
    """Récupère les mots-clés organiques d'un domaine"""
    params = {
        'type': 'domain_organic',
        'domain': domain,
        'database': country,
        'display_limit': limit,
        'export_columns': 'Ph,Po,Nq,Cp,Co,Td',
        'display_sort': 'nq_desc'
    }

    data = semrush_request('', params)
    # Parse le CSV retourné
    lines = data.strip().split('n')
    headers = lines[0].split(';')
    rows = [line.split(';') for line in lines[1:]]

    df = pd.DataFrame(rows, columns=headers)
    return df

# Utilisation
keywords_df = get_domain_organic_keywords('example.com')
print(f"Nombre de mots-clés trouvés: {len(keywords_df)}")

Exemple 2 : Analyse de gap de mots-clés

def keyword_gap_analysis(my_domain, competitor_domain, country="fr"):
    """Trouve les mots-clés du concurrent absents chez vous"""

    # Mots-clés de mon domaine
    my_keywords = set(get_domain_organic_keywords(my_domain)['Keyword'].tolist())

    # Mots-clés du concurrent
    comp_keywords = set(get_domain_organic_keywords(competitor_domain)['Keyword'].tolist())

    # Gaps : présents chez le concurrent, absents chez moi
    gaps = comp_keywords - my_keywords

    return list(gaps)

# Utilisation
gaps = keyword_gap_analysis('my-site.com', 'competitor.com')
print(f"Opportunités de mots-clés identifiées: {len(gaps)}")

Exemple 3 : Surveillance quotidienne automatique

import json
from datetime import datetime

def daily_monitoring_report(domains_to_track, alert_threshold=20):
    """Génère un rapport quotidien de monitoring"""
    report = {
        'date': datetime.now().strftime('%Y-%m-%d'),
        'domains': {}
    }

    for domain in domains_to_track:
        keywords_data = get_domain_organic_keywords(domain, limit=10)

        report['domains'][domain] = {
            'total_keywords': len(keywords_data),
            'top_keywords': keywords_data.head(5).to_dict(),
        }

    # Sauvegarde du rapport
    with open(f"seo_report_{report['date']}.json", 'w') as f:
        json.dump(report, f, ensure_ascii=False, indent=2)

    print(f"Rapport généré : seo_report_{report['date']}.json")
    return report

Cas d’usage avancés que j’automatise pour mes clients

Monitoring concurrent automatique (cron quotidien)

J’ai mis en place pour plusieurs clients un script cron qui tourne chaque matin :

1. Récupère les top 100 mots-clés organiques de 5 concurrents
2. Détecte les changements de position > 5 places
3. Identifie les nouveaux mots-clés entrants dans leur top 10
4. Envoie une alerte Slack si changements significatifs

Le test que j’ai mené montre que ce monitoring automatique détecte les mouvements concurrentiels 48 à 72h plus vite que la veille manuelle hebdomadaire.

Reporting client automatisé

Chaque premier du mois, un script Semrush API génère automatiquement :

• Évolution du trafic organique estimé vs N-1
• Top 20 mots-clés avec évolution de position
• Nouveaux backlinks du mois
• Health Score de l’audit technique

Ce rapport est directement injecté dans un template Google Data Studio. Résultat : 4 heures de reporting mensuel éliminées, remplacées par 15 minutes de vérification et commentaire.

Audit de masse pour grandes migrations

Pour les migrations SEO de sites avec 100 000+ URLs, l’API permet de :

• Extraire la liste complète des pages indexées
• Vérifier les positions pré-migration pour les 5 000 pages les plus importantes
• Comparer post-migration pour détecter les pertes

Sans l’API, ce type d’audit est humainement impossible en temps raisonnable.

Bonnes pratiques et limitations

Gestion du rate limiting : Semrush limite les requêtes API. Implémentez un délai de 0.5 à 1 seconde entre requêtes et gérez les erreurs 429 (Too Many Requests).

Optimiser la consommation de crédits : n’extrayez que les colonnes nécessaires (export_columns paramètre), limitez les résultats par requête avec display_limit.

Sécurité : ne committez jamais votre clé API dans Git. Utilisez les variables d’environnement.

Cache local : pour les données peu volatiles (Authority Score, volumes mensuels), mettez en cache localement pour éviter des requêtes redondantes.

Où trouver l’API Semrush ?

La clé API est disponible dans votre compte Semrush sous Profile > API. La documentation complète est sur developers.semrush.com avec des exemples pour Python, PHP, JavaScript et d’autres langages.

Articles connexes