# Verifica dei profili Instagram prima di una campagna pubblicitaria: report delle discrepanze con Python

https://jsonscraper.com/it/blog/verifica-profili-instagram-campagna-report-python

Author: Michael Johnson

Published: 2026-11-19T11:38:11+00:00

Updated: 2026-11-19T11:38:11+00:00

Recupera i dati pubblici degli account indicati nel brief e crea una tabella delle eccezioni prima di avviare la campagna

Verificare gli account Instagram prima di avviare una campagna aiuta a individuare gli errori nell’elenco delle collaborazioni quando è ancora facile correggerli. Per esempio, il brief potrebbe contenere un nome scritto male, un account duplicato o un profilo con un numero di follower inaspettato. Di seguito trovi un semplice script Python che richiede i dati pubblici per ogni nome utente, confronta la risposta con i criteri definiti e salva in un CSV le righe da controllare.

 

## Quale sarà il risultato

 

In ingresso si fornisce un CSV con l’elenco degli account e, facoltativamente, i valori attesi. In uscita si ottiene una riga separata per ogni nome utente elaborato: lo stato della richiesta, il nome del profilo, l’indicazione di verifica, il numero di follower, di pubblicazioni e di account seguiti, oltre a un breve elenco delle discrepanze rilevate.



![Articolo: Verifica dei profili Instagram prima di una campagna pubblicitaria: report delle discrepanze con Python
Riepilogo: Se il brief contiene nomi di account errati, spazi superflui o un profilo non adatto, il team potrebbe accorgersene solo dopo aver preparato la campagna. Ecco come verificare i nomi utente Instagram tramite l’endpoint documentato di jsonscraper ed esportare in CSV le discrepanze rilevate.
Ruolo dell’immagine: copertina — idea centrale
Sezione: Quale sarà il risultato
Soggetto visivo: foto editoriale " loading=](https://jsonscraper.com/assets/uploads/journal/2026/11/84aacded9a89d423a6289b53b549643f.png.hero.webp)

Il report riunisce i campi verificati del profilo e le annotazioni da controllare manualmente prima di avviare la campagna.© jsonscraper · creato con IA

 

Un report del genere è utile al marketer che confronta i collaboratori con il brief e allo sviluppatore che integra un controllo interno in un’attività ricorrente. Si tratta di una verifica di specifici campi del profilo pubblico al momento della richiesta; la decisione finale sulla conformità alla campagna spetta al team.

 

## Quali campi si possono verificare

 

L’endpoint documentato dell’API Instagram `/v1/user/by/username` richiede il parametro `username`. Nel formato di risposta osservato, i dati del profilo si trovano nell’oggetto `ig`; tra i campi restituiti figurano `username`, `full_name`, `is_private`, `is_verified`, `media_count`, `follower_count`, `following_count` e `biography`. I campi possono non essere sempre presenti, quindi lo script qui sotto registra come vuoti i valori mancanti e non li converte in zero. L’elenco degli endpoint e dei nomi dei parametri è disponibile nella [documentazione dell’API Instagram](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md).

 

Il controllo è particolarmente utile per i criteri esprimibili in modo esplicito: il profilo deve essere pubblico, il numero di follower deve rientrare nell’intervallo stabilito e l’indicazione di verifica deve corrispondere a quanto richiesto nel brief. La biografia può essere salvata per una verifica successiva, ma confrontarne automaticamente il testo con il posizionamento di marketing richiede un criterio separato.

 

## Prepara il file di input

 

Crea `profiles.csv` in UTF-8. La versione minima contiene solo il nome utente; lascia vuoti gli altri campi attesi se il brief non prevede vincoli:

 

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

 

I valori `min_followers` e `max_followers` definiscono i limiti da verificare. Il campo `verified` accetta `true` o `false`. Per ciascun profilo puoi indicare soltanto i criteri applicabili.

 

## Richiedi i dati e genera il report

 

Installa `requests` e imposta la chiave nell’ambiente del processo, non nel file sorgente. Su macOS o Linux, il comando è:



![Articolo: Verifica dei profili Instagram prima di una campagna pubblicitaria: report delle discrepanze con Python
Riepilogo: Se il brief contiene nomi di account errati, spazi superflui o un profilo non adatto, il team potrebbe accorgersene solo dopo aver preparato la campagna. Ecco come verificare i nomi utente Instagram tramite l’endpoint documentato di jsonscraper ed esportare in CSV le discrepanze rilevate.
Ruolo dell’immagine: illustrazione di supporto 2 — un aspetto specifico diverso
Sezione: Richiedi i dati e genera il report](https://jsonscraper.com/assets/uploads/journal/2026/11/146a636928d29c035050cacd0aa101b8.png.hero.webp)

Lo schema mostra il percorso dal CSV con l’elenco degli account al report: i campi vuoti restano tali e le corrispondenze con i criteri vengono indicate separatamente.© jsonscraper · illustrazione generata con IA

 

```
python -m pip install requests
export JSONSCRAPER_INSTAGRAM_LICENSE_KEY='la-tua-chiave'
```

 

Salva lo script seguente come `check_profiles.py`. Usa Python 3.8 o versioni successive, controlla lo stato della risposta HTTP, legge separatamente il payload `ig` e crea `profile_check.csv`. La chiave viene passata come parametro della query `license_key`, come indicato nella documentazione del servizio.

 

```
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("Imposta JSONSCRAPER_INSTAGRAM_LICENSE_KEY")


def parse_bool(value: str) -> Optional[bool]:
    normalized = value.strip().lower()
    if normalized in ("true", "1", "yes", "sì"):
        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"Righe elaborate: {len(output)}; report: profile_check.csv")
```

 

## Come leggere le righe con discrepanze

 

Esegui `python check_profiles.py`. Nella colonna `status`, il valore `ok` indica che lo script ha ricevuto l’oggetto profilo previsto e ha potuto creare una riga. La colonna `issues` contiene solo i criteri verificati: per esempio, `private_profile` o `below_min_followers`. Una colonna vuota significa che le condizioni registrate non hanno rilevato discrepanze; non conferma la qualità dei contenuti né la conformità ad altri punti del contratto.

 

Confronta `returned_username` con il nome utente originale e sottoponi `biography` e `full_name` a un responsabile per una verifica qualitativa. Il report include anche gli errori di richiesta, uno stato API inatteso e l’assenza dell’oggetto `ig`: queste righe restano nel risultato e aiutano a distinguere un problema tecnico dall’esito del controllo.

 

## Come eseguire il controllo regolarmente

 

Per un controllo occasionale basta eseguire lo script manualmente. In un processo ricorrente, aggiungilo a un pianificatore o a un flusso di lavoro CI: carica l’elenco aggiornato, esegui le richieste, salva il CSV come artefatto e avvisa il team se nella colonna `issues` compaiono valori. Non stampare la chiave nei log; conservala come segreto dell’ambiente di esecuzione.

 

Se controlli spesso gli stessi profili, puoi passare il parametro `cache_timeout` indicando il numero di secondi di memorizzazione nella cache. La documentazione specifica che, per Instagram, la cache è disattivata per impostazione predefinita; un valore maggiore di zero la attiva per il periodo indicato. Aggiungere questo parametro ha senso solo se è accettabile riutilizzare la risposta durante l’intervallo selezionato.

 

Verifica soltanto i dati e gli scenari per cui disponi di un’autorizzazione. Usa il risultato come istantanea di una specifica risposta API, registra la data di esecuzione nel tuo registro e rivedi le soglie insieme al brief. Per i dettagli sull’endpoint, i campi disponibili e le opzioni di integrazione, consulta la pagina [Instagram Scraper API](https://jsonscraper.com/services/ig-scraper-api) e la [documentazione ufficiale dell’endpoint](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md).
