IG : détecter les problèmes des profils publics avant une campagne

Avant le lancement d’une campagne, un script peut traiter une liste de comptes IG et produire un rapport JSON contenant la réponse de l’API pour chaque nom. Le point de terminaison IG Scraper API de jsonscraper renvoie un statut externe et un objet de profil ; le schéma observé comprend le nom d’utilisateur, les indicateurs de confidentialité et de vérification, ainsi que le nombre de publications, d’abonnés et d’abonnements. Ces champs permettent de sélectionner les entrées à contrôler manuellement, mais ne suffisent pas à expliquer pourquoi une réponse est absente ou inattendue.

Le problème : la liste des comptes semble correcte, mais est-elle prête à l’emploi ?

Une feuille de campagne peut contenir des comptes dont le nom a changé, des fautes de frappe et des profils privés. Si l’équipe commence à analyser la liste sans vérification préalable, quelqu’un doit ouvrir les comptes un par un. Un passage automatisé réduit le travail manuel et conserve un journal uniforme de ce que l’API a renvoyé pour chaque nom demandé.

La portée de ce scénario est limitée : parcourir la liste, enregistrer les réponses HTTP réelles et signaler les profils présentant des caractéristiques pertinentes pour la campagne afin qu’ils soient contrôlés manuellement. Le rapport consigne les données observées ; il ne détermine pas pourquoi un profil n’a pas été renvoyé ni pourquoi une requête a échoué.

Ce que vérifie la requête

La documentation de jsonscraper indique le point de terminaison GET \/v1\/user\/by\/username. Le paramètre obligatoire est username ; la clé est transmise sous le nom license_key. Le paramètre facultatif cache_timeout active la mise en cache pour un nombre de secondes donné ; la valeur 0 la laisse désactivée. Le schéma observé d’une réponse réussie comprend un status externe et un objet ig contenant les champs du profil.

Pour le diagnostic, distinguez trois faits : la requête HTTP a-t-elle abouti ; le JSON analysé contient-il un objet ig ; quels champs figurent dans cet objet ? Si une étape ne se déroule pas comme prévu, le script peut consigner le résultat technique et la réponse d’origine. Ce résultat signale qu’une vérification est nécessaire, mais n’établit pas la cause de l’échec.

Préparer les données d’entrée et la clé

Créez un fichier usernames.txt avec un nom d’utilisateur par ligne, sans le caractère @. Supprimez les lignes vides et les doublons, et ne conservez que les comptes concernés par la campagne. Pour comparer les résultats ultérieurement, stockez séparément la date du contrôle et l’identifiant du projet.

Stockez la clé dans la variable d’environnement JSONSCRAPER_INSTAGRAM_LICENSE_KEY, et non dans le code source ou le dépôt :

export JSONSCRAPER_INSTAGRAM_LICENSE_KEY="votre_clé"
python3 check_profiles.py

L’exemple utilise la bibliothèque standard de Python 3.8+ et ne nécessite pas l’installation de bibliothèques HTTP.

Exemple : interroger les profils et enregistrer le rapport

Le script parcourt la liste, un nom à la fois. En cas de réponse JSON réussie, il enregistre le corps reçu et les champs de profil disponibles ; en cas d’erreur HTTP ou réseau, il consigne le résultat technique correspondant. Les champs absents restent à null, et le corps brut de la réponse est conservé s’il a pu être lu.

import json
import os
import time
from datetime import datetime, timezone
from urllib.error import HTTPError, URLError
from urllib.parse import urlencode
from urllib.request import Request, urlopen

API_KEY = os.environ.get("JSONSCRAPER_INSTAGRAM_LICENSE_KEY")
if not API_KEY:
    raise SystemExit("Définissez JSONSCRAPER_INSTAGRAM_LICENSE_KEY")

BASE_URL = "https:\/\/ig.jsonscraper.com\/v1\/user\/by\/username"

with open("usernames.txt", encoding="utf-8") as f:
    usernames = list(dict.fromkeys(
        line.strip().lstrip("@") for line in f if line.strip()
    ))

results = []
for username in usernames:
    params = urlencode({"username": username, "license_key": API_KEY})
    request = Request(f"{BASE_URL}?{params}", method="GET")
    checked_at = datetime.now(timezone.utc).isoformat()

    try:
        with urlopen(request, timeout=30) as response:
            http_status = response.status
            raw_body = response.read().decode("utf-8")
        try:
            payload = json.loads(raw_body)
            json_error = None
        except json.JSONDecodeError as exc:
            payload = None
            json_error = str(exc)

        profile = payload.get("ig") if isinstance(payload, dict) else None
        record = {
            "requested_username": username,
            "checked_at": checked_at,
            "http_status": http_status,
            "api_status": payload.get("status") if isinstance(payload, dict) else None,
            "check_result": "profile_returned" if isinstance(profile, dict) else "unexpected_or_missing_profile_object",
            "response": payload if payload is not None else raw_body,
        }
        if json_error:
            record["json_error"] = json_error
        if isinstance(profile, dict):
            record["returned_username"] = profile.get("username")
            record["is_private"] = profile.get("is_private")
            record["is_verified"] = profile.get("is_verified")
            record["media_count"] = profile.get("media_count")
            record["follower_count"] = profile.get("follower_count")
            record["following_count"] = profile.get("following_count")
        results.append(record)
    except HTTPError as exc:
        body = exc.read().decode("utf-8", errors="replace")
        results.append({
            "requested_username": username,
            "checked_at": checked_at,
            "check_result": "http_error",
            "http_status": exc.code,
            "response": body,
        })
    except (URLError, TimeoutError) as exc:
        results.append({
            "requested_username": username,
            "checked_at": checked_at,
            "check_result": "request_error",
            "detail": str(exc),
        })

    time.sleep(0.5)

with open("profile-check.json", "w", encoding="utf-8") as f:
    json.dump(results, f, ensure_ascii=False, indent=2)

print(f"Résultats enregistrés : {len(results)}")

Il s’agit d’un exemple d’intégration, et non du compte rendu d’un test effectué. La clé est transmise dans le paramètre license_key, mais n’est pas affichée. La réponse complète peut contenir des informations dont l’accès doit être limité conformément aux règles de conservation des données de votre équipe.

Comment lire le résultat

Un enregistrement profile_returned signifie que le script a reçu un objet JSON ig. Comparez requested_username à returned_username et examinez les indicateurs importants pour le processus de campagne. Par exemple, is_private: true peut entraîner un contrôle manuel si la campagne exige un profil public.

Les résultats http_error, request_error et unexpected_or_missing_profile_object indiquent uniquement l’étape à laquelle le script n’a pas obtenu la structure attendue. Ils ne prouvent pas que le compte a été supprimé, est privé ou est inaccessible pour une raison précise. Enregistrez la réponse, vérifiez le nom et la clé, puis réessayez ou contactez le support habituel du service.

Si un champ est absent, laissez-le indéterminé : ne l’interprétez ni comme zéro ni comme false. Les compteurs du profil décrivent l’état renvoyé au moment de la requête. L’horodatage permet de distinguer cet instantané des résultats d’une exécution ultérieure.

Automatiser sans perdre en observabilité

Intégrez l’exécution à un planificateur de tâches ou à une étape d’un processus ETL existant. Conservez la date du contrôle, le nom demandé, le résultat, le statut et le corps de la réponse. Dans une étape distincte, vous pouvez charger le JSON dans un tableau et n’envoyer au spécialiste que les enregistrements nécessitant une vérification.

Pour détecter les changements, comparez les instantanés d’un même profil selon les champs choisis. Une variation du nombre de publications invite à ouvrir le profil et à le vérifier, mais ne donne pas la date exacte d’apparition d’une publication. Le nombre d’abonnés est lui aussi une valeur relevée au moment de la requête ; l’historique des observations se construit donc à partir des instantanés enregistrés.

Pour les listes volumineuses, adoptez un rythme contrôlé, ajoutez des tentatives répétées avec une limite et tenez un journal des erreurs. N’incluez pas la clé dans les journaux d’URL. Stocker séparément la liste d’entrée et les résultats aide à déterminer quels comptes ont déjà été traités.

Résultat attendu

Le résultat est un fichier JSON contenant, pour chaque nom soumis, le résultat du traitement, un horodatage, les attributs disponibles et la réponse enregistrée. Avant de transmettre la liste à la campagne, vous pouvez filtrer les noms correspondants, les profils privés et les cas techniques à examiner manuellement. L’équipe définit elle-même les critères de l’étape suivante.

Le point de terminaison et ses paramètres sont décrits dans la documentation de l’API IG ; les informations sur le produit figurent sur la page IG Scraper API. Commencez par un petit échantillon, vérifiez la forme réelle des réponses et adaptez les règles du rapport à votre processus.