Aller au contenu
SEO Tools AI
SEO Tools AIS'inscrire

Recette

Synchronisez les scores de liens depuis une feuille ou n8n

La plupart des répertoires d'outils sont hébergés dans une feuille de calcul, une base Airtable ou une petite base de données. Cette recette transforme une vérification de backlinks en remplissage de colonnes : une requête pour 2 000 lignes.

Équipe de recherche SEO Tools AI ·

Des ouvriers en papier découpé construisant un pont reliant un classeur à une route

La recette en cinq étapes

01

Exportez les domaines

Prenez la colonne des sites web de vos listes, supprimez le protocole et les chemins, et retirez les doublons. Les doublons ne coûtent pas cher en supplément, mais rendent l'étape de mappage plus désordonnée.

02

Découpez en groupes de 2 000

bulk_dr accepte jusqu'à 2 000 domaines par appel. Une feuille de 5 000 lignes nécessite donc trois appels.

03

Envoyez, vérifiez le statut ok

Appelez l'API, lisez le JSON et arrêtez si ok est faux. Journalisez _credits pour voir le solde après chaque exécution.

04

Écrivez de retour avec une date

Enregistrez la note et la date du jour dans deux colonnes. Ne remplacez jamais une bonne valeur par une valeur vide.

05

Planifiez une fois par mois

Lancez-le le premier du mois. L'index évoluant environ mensuellement, une fréquence plus élevée n'apporte rien.

Choisissez ce qui déclenche la tâche

Le déclencheur détermine la fréquence des appels, donc choisissez-le avant de construire le mappage. Deux modes de déclenchement couvrent presque tous les répertoires.

Un planifié le premier du mois est l'option la plus simple. Il correspond au rythme de l'index, et personne n'a besoin de se souvenir d'appuyer sur un bouton.

Un planifié pour le rafraîchissement mensuel

Placez un déclencheur de planifié en premier, réglez-le sur le premier jour de chaque mois, et laissez-le lire toute la table des listes. Chaque exécution effectue alors un lot d'appels bulk_dr, dimensionné selon le nombre de lignes.

Conservez le planifié même si la table est petite. Une tâche mensuelle qui s'exécute sur une petite feuille coûte un crédit, et cela maintient les notes datées et à jour.

Un déclencheur sur chaque nouvelle ligne

Supposons que les listes arrivent une à une, tous les quelques jours. Un déclencheur qui se déclenche par nouvelle ligne est tentant, mais chaque appel est facturé une fois, donc un appel par ligne coûte plus cher qu'un lot pour le mois.

Si vous voulez le score rapidement, laissez le flux de nouvelle ligne écrire un dr vide et laissez l'exécution mensuelle le remplir. La ligne obtient son numéro sans appel à chaque arrivée.

Si les listes arrivent par rafales, regroupez les nouvelles lignes en un seul lot à la fin de la semaine. Cela coûte un appel, et la feuille ne change plus une seule fois par mois.

Une date qui marque les lignes terminées

Enregistrez dr_checked_on sur chaque ligne que vous notez. Une exécution qui commence par un filtre sur cette date saute ce qui est déjà fait ce mois-ci, et aucune file d'attente séparée n'est nécessaire.

Quand une exécution s'arrête en cours de route, les lignes déjà estampillées restent estampillées. La prochaine exécution reprend là où la dernière s'est arrêtée, ce qui est la récupération la moins coûteuse.

Avant d'automatiser quoi que ce soit

Effectuez d'abord la vérification manuellement sur cinq listes. Utilisez l'action gratuite overview pour chacune, qui ne nécessite pas de clé, et comparez ce que vous voyez avec ce à quoi vous vous attendiez.

Cela permet de détecter tôt les surprises courantes : une liste qui pointe vers un sous-domaine, un produit hébergé sur un chemin d'un site plus vaste, un domaine qui a redirigé le printemps dernier. Une note s'applique à un domaine, pas à un produit.

Décidez comment votre feuille marque ces cas, par exemple avec une colonne de note indiquant shares domain. Les lecteurs pardonnent bien plus facilement une note de bas de page qu'un score qui semble erroné.

Lorsque les cinq semblent cohérents, passez au lot. Votre référence de champ liste les colonnes, et l'exemple de coût montre ce qu'une exécution coûte.

Une petite version Python

Nécessite le package requests. C'est un croquis de la structure de la tâche : imprimez d'abord une vraie réponse, puis mappez les champs dont vous avez besoin dans vos propres colonnes.

python
import csv, requests

KEY = "sk_live_..."
BASE = "https://seotoolsai.org/api.php"

rows = list(csv.DictReader(open("listings.csv")))
domains = sorted({r["domain"] for r in rows})

for i in range(0, len(domains), 2000):
    chunk = domains[i:i + 2000]
    r = requests.post(BASE, params={"action": "bulk_dr", "key": KEY},
                      data={"domains": ",".join(chunk)}, timeout=60)
    if r.status_code in (401, 402):
        raise SystemExit(f"stop: HTTP {r.status_code}")
    data = r.json()
    if not data.get("ok"):
        raise SystemExit("api said not ok")
    print(data["_credits"])   # cost and remaining balance
    open(f"raw_{i}.json", "w").write(r.text)
Des engrenages et des tapis roulants en papier triant des blocs en groupes

Le faire dans Google Sheets ou n8n

Sheets peut appeler une URL depuis Apps Script avec UrlFetchApp, et n8n dispose d'un nœud HTTP Request. Les deux font la même chose que le script ci-dessus.

Dans n8n, placez un déclencheur de planifié en premier, puis un nœud qui lit votre feuille ou table, puis une étape de division des éléments qui construit des groupes de 2 000, puis le HTTP Request. Ajoutez un nœud final qui écrit la note et la date de retour.

Conservez la clé dans le magasin d'identifiants de la plateforme, pas dans le texte du workflow. Les workflows sont partagés, copiés et collés dans des forums, et une clé collée avec eux est de l'argent dépensé.

No-code ou un script : quelle forme convient à votre équipe

Les deux routes effectuent le même appel. La différence réside dans qui devra maintenir le flux dans un an, et dans la facilité à l'expliquer à cette personne.

Choisissez la forme que vous pouvez encore lire après une pause de plusieurs mois. Un flux ingénieux que personne ne comprend est pire qu'un script simple que tout le monde peut suivre.

Un flux que vous pouvez expliquer au prochain éditeur

Un court flux n8n avec quatre nœuds étiquetés est facile à transmettre : trigger, read, batch, write back. Nommez chaque nœud selon ce qu'il fait, pas selon l'étiquette par défaut.

Évitez d'empiler de nombreuses branches pour les cas limites. Chaque branche est un endroit supplémentaire où un domaine peut obtenir un score incorrect.

Quand un script justifie sa place

Un script a du sens lorsque l'entrée est un dossier de fichiers CSV, ou lorsque la tâche nécessite une logique qu'un flux gère mal. Le croquis ci-dessus convient à ce cas.

Placez le script dans un contrôle de version et conservez la clé dans une variable d'environnement. Un script qui lit sa clé depuis un fichier dans le même dossier est une fuite en attente d'un lecteur réseau partagé.

Des tutoriels qui passent sous silence la partie difficile

De nombreuses vidéos montrent un flux qui fonctionne du premier coup avec trois lignes. Les vraies listes contiennent des champs vides, des doublons et des domaines étranges, et c'est là que le flux nécessite une attention particulière.

Construisez le flux sur vos propres cinq lignes de test d'abord. Si un tutoriel ne survit pas à ces tests, il ne couvrait jamais l'intégralité du travail.

Lorsque vous transmettez le flux à quelqu'un d'autre, incluez les cinq lignes de test comme exemple. La personne suivante pourra voir à quoi ressemble une bonne exécution avant de toucher aux données réelles.

Ce que signifient les erreurs

Comportement de l'API et ce qu'une tâche de synchronisation doit faire.
SignalSignificationCe que fait la tâche
HTTP 401Clé manquante ou incorrecteArrêter, alerter un humain
HTTP 402Les crédits sont épuisésArrêter, conserver les anciennes valeurs, recharger
ok est fauxL'appel n'a pas aboutiJournaliser le corps de la réponse, réessayer lors de la prochaine exécution
Résultat vide pour un domaineNon indexéLaisser la cellule vide
Un jardinier en papier redressant la torte courbée d'une plante dans un jardin

Conserver le tableau propre entre les exécutions

Une tâche de synchronisation n'est bonne que si le tableau qu'elle remplit l'est aussi. Quelques habitudes évitent les dégradations lentes qui s'accumulent d'une exécution à l'autre.

La plupart des problèmes commencent par une modification innocente : une colonne insérée au-dessus de la valeur, ou une ligne copiée qui modifie silencieusement un domaine.

Conserver les réponses brutes dans un onglet dédié

Stocker chaque réponse brute dans son propre onglet, ou en format JSON Lines avec une réponse par ligne. Cette copie permet de reconstruire les colonnes visibles sans effectuer un second appel payant.

Un onglet brut répond également à la question qu'un rédacteur se pose six mois plus tard : qu'a retourné l'API à cette date.

Nommer chaque onglet brut avec la date du lot, afin que les copies se trient automatiquement lorsque vous les consultez.

Verrouiller la ligne d'en-tête

Geler la ligne d'en-tête et ne jamais insérer de colonne au-dessus de la valeur. Une mappage qui pointe vers la colonne F lira les mauvaises données après une insertion, et ce sans aucune erreur.

Nommer les colonnes dans le mappage, et non par position. Un nom survit à un réordonnancement, contrairement à une position.

Compter les lignes avant et après

Écrire le nombre de lignes dans le journal avant l'exécution et à nouveau après. Les deux nombres ne devraient différer que par les lignes que vous aviez l'intention d'ajouter, et un écart indique qu'une erreur s'est produite.

Trier le tableau par la colonne de valeur une fois par mois et examiner les lignes du haut et du bas. Des valeurs étranges à ces endroits indiquent généralement un domaine mappé à une entrée incorrecte.

Tester d'abord sur une copie

Dupliquer le tableau et exécuter le flux sur la copie avant de toucher au tableau réel. Une copie ne coûte rien à créer.

Un mappage incorrect écrit sur des valeurs réelles est difficile à annuler, car les anciennes valeurs sont perdues. Conservez la copie jusqu'à ce que la première exécution honnête corresponde à vos attentes.

Supprimer la copie uniquement après que la deuxième exécution planifiée l'ait confirmée. Deux exécutions propres consécutives sont un meilleur signal qu'une seule.

Avant la première exécution en production

  • La clé est stockée dans le magasin d'identifiants de la plateforme ou dans une variable d'environnement, et non dans le texte du flux de travail.
  • Un appel overview gratuit a été vérifié manuellement par rapport à une entrée que vous connaissez.
  • L'exécution a été testée sur une copie du tableau, et la copie correspondait à vos attentes.
  • La tâche inscrit la date à côté de chaque valeur qu'elle modifie.
  • Le statut 401 et 402 arrêtent la tâche et envoient un message à une personne.

Questions sur la synchronisation

Comment éviter de payer deux fois si la tâche plante en cours de route ?

Inscrivez la date à côté de chaque valeur au fur et à mesure, et faites en sorte que la prochaine exécution saute les lignes déjà datées ce mois-ci. Des lots de 2 000 lignes signifient qu'un plantage coûte au maximum un crédit, donc le risque est minime, mais cette habitude garde le tableau propre.

Un non-développeur peut-il configurer cela ?

Pour la plupart, oui. Un nœud HTTP Request dans n8n ou Make nécessite uniquement une URL, une clé et une liste. La partie délicate consiste à transformer la réponse en colonnes, donc faites un appel de test et examinez le JSON avant de construire le mappage.