jsonscraper
Marchés
Retour au journal

Vérifier les profils IG avant une campagne publicitaire avec Python

Récupérez les informations publiques des comptes du brief et créez un tableau des écarts avant le lancement de la campagne

Politique éditoriale Signaler une erreur

Vérifier les comptes IG avant le lancement d’une campagne permet de repérer les erreurs dans la liste des placements tant qu’elles sont encore faciles à corriger. Le brief peut, par exemple, contenir une faute dans un nom, un compte en double ou un profil dont le nombre d’abonnés est inattendu. Voici un petit script Python qui demande les données publiques pour chaque nom d’utilisateur, compare la réponse à vos critères et enregistre les lignes vérifiables dans un fichier CSV.

Résultat obtenu

Le fichier d’entrée est un CSV contenant une liste de comptes et, facultativement, les valeurs attendues. Le résultat comprend une ligne distincte pour chaque nom d’utilisateur traité : statut de la requête, nom du profil, indication de vérification, nombre d’abonnés, de publications et d’abonnements, ainsi qu’une courte liste des écarts détectés.

Article : Vérifier les profils IG avant une campagne publicitaire avec Python
Résumé : Si le brief contient des noms de comptes erronés, des espaces superflus ou un profil inadapté, l’équipe risque de ne le découvrir qu’après la préparation de la campagne. Voici comment vérifier les noms d’utilisateur IG à l’aide du point de terminaison documenté de jsonscraper et exporter les écarts observés dans un fichier CSV.
Rôle de l’image : couverture — idée centrale
Section : Résultat obtenu
Sujet visuel : Photo éditoriale « »
Le rapport rassemble les champs de profil vérifiés et les indications à examiner manuellement avant le lancement de la campagne.© jsonscraper · créé avec l’IA

Ce rapport est utile au spécialiste marketing qui vérifie les prestataires par rapport au brief, comme au développeur qui met en place un contrôle interne récurrent. Il vérifie certains champs du profil public au moment de la requête ; c’est à l’équipe de décider si le profil convient à la campagne.

Champs vérifiables

Le point de terminaison documenté de l’API IG /v1/user/by/username exige le paramètre username. Dans le format de réponse observé, les données du profil se trouvent dans l’objet ig ; les champs renvoyés comprenaient username, full_name, is_private, is_verified, media_count, follower_count, following_count et biography. Les champs peuvent être absents : le script ci-dessous enregistre donc les valeurs manquantes comme des cellules vides, sans les convertir en zéro. La documentation de l’API IG répertorie les points de terminaison et les noms des paramètres.

Le contrôle est particulièrement utile pour les critères que l’on peut définir explicitement : le profil doit être public, le nombre d’abonnés doit se situer dans une plage définie et l’indication de vérification doit correspondre à l’exigence du brief. La biographie peut être conservée pour examen ultérieur, mais comparer automatiquement son texte au positionnement marketing nécessiterait un critère distinct.

Préparer le fichier d’entrée

Créez un fichier profiles.csv encodé en UTF-8. La version minimale ne contient que le nom d’utilisateur ; laissez les champs attendus supplémentaires vides si le brief ne précise pas de contrainte :

username,min_followers,max_followers,verified
brand_example,5000,50000,false
creator_example,10000,,true

Les valeurs min_followers et max_followers définissent les limites du contrôle. Le champ verified accepte true ou false. Vous pouvez n’indiquer que les critères applicables à chaque profil.

Récupérer les données et générer le rapport

Installez requests et définissez la clé dans l’environnement du processus, plutôt que dans le fichier source. Sous macOS ou Linux, la commande est la suivante :

Article : Vérifier les profils IG avant une campagne publicitaire avec Python
Résumé : Si le brief contient des noms de comptes erronés, des espaces superflus ou un profil inadapté, l’équipe risque de ne le découvrir qu’après la préparation de la campagne. Voici comment vérifier les noms d’utilisateur IG à l’aide du point de terminaison documenté de jsonscraper et exporter les écarts observés dans un fichier CSV.
Rôle de l’image : illustration complémentaire 2 — un aspect spécifique différent
Section : Récupérer les données et générer le rapport
Sujet visuel : »
Le schéma illustre le parcours du CSV contenant la liste des comptes au rapport : les champs vides restent vides et les correspondances avec les règles sont indiquées séparément.© jsonscraper · illustration générée par l’IA
python -m pip install requests
export JSONSCRAPER_INSTAGRAM_LICENSE_KEY='votre-clé'

Enregistrez le script ci-dessous sous le nom check_profiles.py. Il utilise Python 3.8 ou une version ultérieure, vérifie le statut HTTP de la réponse, lit séparément la charge utile ig et crée profile_check.csv. La clé est transmise en tant que paramètre de requête license_key, conformément à la documentation du service.

import csv
import os
import sys
from typing import Dict, List, Optional

import requests

API_URL = "https://ig.jsonscraper.com/v1/user/by/username"
API_KEY = os.environ.get("JSONSCRAPER_INSTAGRAM_LICENSE_KEY")

if not API_KEY:
    raise SystemExit("Définissez JSONSCRAPER_INSTAGRAM_LICENSE_KEY")


def parse_bool(value: str) -> Optional[bool]:
    normalized = value.strip().lower()
    if normalized in ("true", "1", "yes", "да"):
        return True
    if normalized in ("false", "0", "no", "нет"):
        return False
    return None


def check_row(row: Dict[str, str]) -> Dict[str, str]:
    username = row.get("username", "").strip().lstrip("@")
    result = {
        "requested_username": username,
        "status": "",
        "returned_username": "",
        "full_name": "",
        "is_private": "",
        "is_verified": "",
        "follower_count": "",
        "media_count": "",
        "following_count": "",
        "biography": "",
        "issues": "",
    }

    if not username:
        result["status"] = "skipped_empty_username"
        result["issues"] = "empty_username"
        return result

    try:
        response = requests.get(
            API_URL,
            params={"license_key": API_KEY, "username": username},
            timeout=30,
        )
        response.raise_for_status()
        payload = response.json()
    except (requests.RequestException, ValueError) as exc:
        result["status"] = "request_error"
        result["issues"] = type(exc).__name__
        return result

    if payload.get("status") != "ok":
        result["status"] = "api_error"
        result["issues"] = "unexpected_outer_status"
        return result

    profile = payload.get("ig")
    if not isinstance(profile, dict):
        result["status"] = "missing_profile_data"
        result["issues"] = "missing_ig_object"
        return result

    result["status"] = "ok"
    fields = (
        "username", "full_name", "is_private", "is_verified",
        "follower_count", "media_count", "following_count", "biography",
    )
    for field in fields:
        value = profile.get(field)
        if value is not None:
            result["returned_username" if field == "username" else field] = str(value)

    issues: List[str] = []
    private = profile.get("is_private")
    if private is True:
        issues.append("private_profile")

    followers = profile.get("follower_count")
    if isinstance(followers, int):
        minimum = row.get("min_followers", "").strip()
        maximum = row.get("max_followers", "").strip()
        if minimum:
            try:
                if followers < int(minimum):
                    issues.append("below_min_followers")
            except ValueError:
                issues.append("invalid_min_followers_rule")
        if maximum:
            try:
                if followers > int(maximum):
                    issues.append("above_max_followers")
            except ValueError:
                issues.append("invalid_max_followers_rule")
    elif row.get("min_followers", "").strip() or row.get("max_followers", "").strip():
        issues.append("follower_count_unavailable")

    expected_verified = parse_bool(row.get("verified", ""))
    actual_verified = profile.get("is_verified")
    if expected_verified is not None and isinstance(actual_verified, bool):
        if actual_verified != expected_verified:
            issues.append("verified_flag_mismatch")
    elif row.get("verified", "").strip():
        issues.append("verified_value_unavailable_or_invalid")

    result["issues"] = ";".join(issues)
    return result


with open("profiles.csv", newline="", encoding="utf-8-sig") as source:
    rows = list(csv.DictReader(source))

output = [check_row(row) for row in rows]
fieldnames = list(output[0].keys()) if output else [
    "requested_username", "status", "returned_username", "full_name",
    "is_private", "is_verified", "follower_count", "media_count",
    "following_count", "biography", "issues",
]

with open("profile_check.csv", "w", newline="", encoding="utf-8") as destination:
    writer = csv.DictWriter(destination, fieldnames=fieldnames)
    writer.writeheader()
    writer.writerows(output)

print(f"Lignes traitées : {len(output)} ; rapport : profile_check.csv")

Lire les lignes signalant des écarts

Lancez python check_profiles.py. Dans la colonne status, la valeur ok signifie que le script a reçu l’objet de profil attendu et a pu créer une ligne. La colonne issues ne contient que les règles vérifiées, par exemple private_profile ou below_min_followers. Une cellule vide signifie qu’aucun écart n’a été détecté au regard des critères renseignés ; elle ne confirme ni la qualité du contenu ni le respect des autres clauses du contrat.

Comparez returned_username au nom d’utilisateur d’origine, puis transmettez biography et full_name à la personne responsable pour un examen du contenu. Le rapport inclut également les erreurs de requête, les statuts API inattendus et l’absence de l’objet ig : ces lignes restent dans les résultats et permettent de distinguer une défaillance technique d’un résultat de vérification.

Exécuter le contrôle régulièrement

Pour un contrôle ponctuel, il suffit d’exécuter le script manuellement. Dans un processus récurrent, ajoutez-le à un planificateur ou à un flux de travail CI : chargez la liste à jour, exécutez les requêtes, enregistrez le CSV comme artefact et avertissez l’équipe si la colonne issues contient des valeurs. N’affichez pas la clé dans les journaux ; conservez-la comme secret dans l’environnement d’exécution.

Si vous vérifiez fréquemment les mêmes profils, vous pouvez transmettre le paramètre cache_timeout pour définir une durée de mise en cache en secondes. La documentation indique que la mise en cache est désactivée par défaut pour IG ; une valeur supérieure à zéro l’active pour la durée indiquée. N’ajoutez ce paramètre que si la réutilisation d’une réponse pendant l’intervalle choisi est acceptable.

Vérifiez uniquement les données et les scénarios pour lesquels vous disposez d’une autorisation. Considérez le résultat comme un instantané d’une réponse précise de l’API, consignez la date d’exécution dans votre propre journal et réexaminez les seuils avec le brief. Pour en savoir plus sur le point de terminaison, les champs disponibles et les possibilités d’intégration, consultez la page IG Scraper API et la documentation officielle du point de terminaison.

Personnes

Aucune personne répertoriée pour cet article pour le moment.

Continuez à lireComment vérifier des prospects TikTok sur IG avant leur transfert dans le CRM
Lire le prochain article

Transformez vos lectures en intégration fonctionnelle

Explorez les API de données sociales de jsonscraper, testez des requêtes et créez votre prochain workflow.

Explorer les API