Puoi estrarre i follower di Instagram con Python inviando uno o più username, URL di profili pubblici o ID utente numerici alla Instagram Followers Scraper API di Datablist tramite la libreria Requests. L’API restituisce i follower in formato JSON e identifica il profilo di origine di ogni relazione.

Questa guida parte dai follower raccolti per Jupiter Hikes, escursionista di lunga distanza e filmmaker. Riutilizzeremo poi la stessa funzione Python per confrontare i suoi follower con quelli di Darwin on the Trail, un altro escursionista e filmmaker outdoor. Il codice raggruppa i risultati in base all’ID utente numerico di Instagram e individua gli utenti presenti in entrambe le liste.

🔑 Riepilogo per chi ha poco tempo

Usa la Instagram Followers Scraper API di Datablist per estrarre con Python i follower di profili Instagram pubblici. Invia i profili da analizzare, imposta un limite per ciascuno e recupera in formato JSON i follower disponibili, pronti per i tuoi workflow di ricerca o marketing. Prima di iniziare, verifica che Instagram consenta di consultare i follower di ogni profilo.

  • Input: username Instagram, URL dei profili o ID utente numerici.
  • Output: record dei follower con ID utente, dati del profilo disponibili e profilo di origine di ciascun follower.

💡 Preferisci una soluzione no-code? Usa la source Instagram Followers di Datablist per generare le righe dei follower senza scrivere codice.

La guida alla raccolta dei follower di Instagram illustra la stessa source attraverso l’interfaccia di Datablist. Il resto di questa guida è dedicato all’API.

Verifica se Instagram limita la lista dei follower

Prima di avviare lo scraping, apri il profilo Instagram di destinazione e fai clic su Follower. Verifica di poter consultare la lista. Un profilo pubblico non garantisce che Instagram mostri tutti i suoi follower.

Se compare il messaggio “Solo [username] può vedere tutti i follower”, aspettati una lista parziale anche se il profilo è pubblico. L’API può recuperare soltanto i follower resi disponibili da Instagram: aumentare il limite richiesto non consente di accedere a quelli nascosti.

L’avviso sulla visibilità dei follower nel profilo Instagram di Levi’s.
L’avviso sulla visibilità dei follower nel profilo Instagram di Levi’s.

Controlla ogni profilo che intendi analizzare, così saprai prima di inviare la richiesta API se la lista accessibile è sufficiente per il tuo obiettivo.

Configura Python e la chiave API Datablist

L’accesso alla REST API di Datablist è incluso nel piano Growth. Anche i task delle source consumano crediti. Analizzeremo i costi della source dei follower dopo il tutorial.

Crea una Personal API Key dalla pagina API del tuo account Datablist. In questo esempio utilizziamo il package requests. Crea una cartella di progetto, aprila nel terminale ed esegui:

shell
python -m venv .venv
source .venv/bin/activate
python -m pip install requests

Crea un file chiamato scrape_instagram_followers.py, quindi inserisci la chiave nella variabile d’ambiente DATABLIST_API_KEY:

shell
export DATABLIST_API_KEY="your-api-key"

Lo script legge questa variabile e ne invia il valore tramite l’header X-API-Key.

Estrai i follower Instagram con una funzione Python

La prima richiesta usa jupiterhikes, lo username dell’escursionista e creator Jupiter Hikes. La source accetta anche l’URL completo del profilo o una stringa contenente l’ID utente numerico di Instagram. Per esempio, l’ID numerico di Jupiter Hikes è "1507518892".

Incolla questo script completo in scrape_instagram_followers.py:

python
import json
import os
import time
import uuid
import requests
def scrape_instagram_users(
profiles,
api_key,
scraping_type="followers",
limit_per_profile=100,
):
"""Invia i profili, attende il task della source e restituisce tutti gli utenti generati."""
tasks_url = "https://api.datablist.com/v1/sources/tasks"
headers = {"X-API-Key": api_key}
unique_id = str(uuid.uuid4())
print(f"Task uniqueId: {unique_id}", flush=True)
payload = {
"sourceId": "instagram-source",
"uniqueId": unique_id,
"settings": {
"profiles": profiles,
"scrapingType": scraping_type,
"limitPerProfile": limit_per_profile,
},
}
response = requests.post(tasks_url, headers=headers, json=payload)
response.raise_for_status()
task = response.json()
task_id = task["@id"]
task_url = f"{tasks_url}/{task_id}"
print(f"Task ID: {task_id}")
while task["status"] not in ("completed", "failed", "stopped"):
time.sleep(3)
response = requests.get(task_url, headers=headers)
response.raise_for_status()
task = response.json()
print(f"Task status: {task['status']}; credits used: {task['credits']['used']}")
if task["status"] != "completed":
raise RuntimeError(
f"Task {task_id} {task['status']}: {task.get('error')}"
)
results = []
params = {"limit": 10}
while True:
response = requests.get(
f"{task_url}/results",
headers=headers,
params=params,
)
response.raise_for_status()
page = response.json()
results.extend(page["results"])
next_cursor = page["nextCursor"]
if next_cursor is None:
break
params["cursor"] = next_cursor
return results
if __name__ == "__main__":
api_key = os.environ.get("DATABLIST_API_KEY")
if not api_key:
raise RuntimeError("Set DATABLIST_API_KEY before running this script.")
profiles = ["jupiterhikes"]
follower_results = scrape_instagram_users(profiles, api_key)
print(json.dumps(follower_results, indent=2, ensure_ascii=False))

Eseguilo con:

shell
python scrape_instagram_followers.py

La funzione effettua in sequenza tre tipi di chiamate API.

  1. POST /v1/sources/tasks invia l’ID e le impostazioni della source. L’API accetta il task in background e ne restituisce l’ID.
  2. GET /v1/sources/tasks/{taskId} controlla il task ogni tre secondi. Il client Requests rimane in attesa, ma il task viene eseguito in modo asincrono su Datablist.
  3. GET /v1/sources/tasks/{taskId}/results recupera una pagina di follower sotto forma di oggetti flat. Il ciclo reinvia ogni nextCursor non nullo senza modificarlo, finché l’API non restituisce null.

L’esempio imposta scrapingType su followers e richiede 100 utenti tramite limitPerProfile. Considera 100 un limite richiesto, non un numero esatto di risultati. I confini delle pagine del provider e gli utenti disponibili durante il task possono modificare il totale restituito.

Lo script stampa uniqueId prima dell’invio. Se la connessione si interrompe durante il POST, questo valore ti aiuta a ritrovare il task accettato, evitando di avviare subito un’altra esecuzione a pagamento.

Come l’API crea i record delle relazioni

Datablist risolve innanzitutto ogni username, URL completo o ID numerico nel relativo profilo Instagram di origine. Il processo in background recupera quindi le pagine dei follower e gestisce il cursor del provider. Devi occuparti soltanto del task Datablist e dei cursor delle pagine dei risultati mostrati nello script.

Gli ID utente ripetuti vengono deduplicati nella lista restituita per un singolo profilo di origine. Se lo stesso utente compare per due creator inviati, l’API conserva due record di relazione. Ognuno presenta valori diversi nei campi followerSourceProfile.... È proprio questo comportamento a rendere possibile il confronto tra le audience.

Nelle prossime sezioni utilizzeremo questi campi:

  • instagramUserId è la chiave stabile con cui confrontare gli utenti restituiti.
  • instagramUsername, instagramFullName e gli altri campi instagram... descrivono il follower quando il dato è pubblico e disponibile.
  • followerSourceProfileId, followerSourceProfileUsername e followerSourceProfileUrl identificano il creator di partenza.

Questa source recupera liste di relazioni. Non cerca potenziali contatti e non calcola confidence score.

Analizza i risultati di Jupiter Hikes

Il task completato per Jupiter Hikes ha restituito 124 follower unici e consumato 2,24 crediti. Anche se la richiesta indicava limitPerProfile: 100, il conteggio era arrivato a 99 quando il provider ha restituito un’altra pagina di 25 utenti. Datablist ha conservato l’intera pagina, portando il totale a 124.

Ecco la risposta dell’ultima pagina dei risultati. L’envelope e tutti e quattro gli oggetti follower sono riportati così come sono stati restituiti:

json
{
"taskId": "695846750eb440c3870e763d38ef4f4b",
"results": [
{
"instagramUserId": "52256365838",
"instagramUsername": "adventuresoforest",
"instagramFullName": "Forest",
"instagramProfileUrl": "https://www.instagram.com/adventuresoforest/",
"instagramPicture": "https://scontent-fra3-2.cdninstagram.com/v/t51.82787-19/809812326_18068055263741839_8426418313724501534_n.jpg?stp=dst-jpg_e0_s150x150_tt6&efg=eyJ2ZW5jb2RlX3RhZyI6InByb2ZpbGVfcGljLmRqYW5nby4xMDgwLmMyIn0&_nc_ht=scontent-fra3-2.cdninstagram.com&_nc_cat=107&_nc_oc=Q6cZ2gGE1JNYkQoszNL29wj7UyG4OGKOarcf_iw1luHzGMllAjP-kLWQ5LQPxtYI3LUcC5g&_nc_ohc=1hyyyEDHulgQ7kNvwFJIKKP&_nc_gid=ATIykjgJSgaEOBqdAnjQcg&edm=AIfao94BAAAA&ccb=7-5&ig_cache_key=GGbBRDCPB8fvzDBAAB4eZa7PpvB0bmNDAQAB1501500j-ccb7-5&oh=00_AQQZ3R0wDeV-bTnR2lYSje_IQ-ly9n6pyxGHXpJGAmzUHA&oe=6AF37F89&_nc_sid=9f8d40",
"followerSourceProfile": "https://www.instagram.com/jupiterhikes/",
"followerSourceProfileId": "1507518892",
"followerSourceProfileUsername": "jupiterhikes",
"followerSourceProfileUrl": "https://www.instagram.com/jupiterhikes/",
"instagramVerified": false,
"instagramPrivate": false
},
{
"instagramUserId": "199102398",
"instagramUsername": "richie_nu_field",
"instagramFullName": "新野 豊",
"instagramProfileUrl": "https://www.instagram.com/richie_nu_field/",
"instagramPicture": "https://scontent-fra3-1.cdninstagram.com/v/t51.2885-19/348434195_2264827180367957_813086592749200065_n.jpg?stp=dst-jpg_e0_s150x150_tt6&efg=eyJ2ZW5jb2RlX3RhZyI6InByb2ZpbGVfcGljLmRqYW5nby42NDAuYzIifQ&_nc_ht=scontent-fra3-1.cdninstagram.com&_nc_cat=105&_nc_oc=Q6cZ2gGE1JNYkQoszNL29wj7UyG4OGKOarcf_iw1luHzGMllAjP-kLWQ5LQPxtYI3LUcC5g&_nc_ohc=xux3gQ4SQEAQ7kNvwGj5tEv&_nc_gid=ATIykjgJSgaEOBqdAnjQcg&edm=AIfao94BAAAA&ccb=7-5&ig_cache_key=GBOvxBRVQJAr2QsIAMHicrzyqUgLbkULAAAB1501500j-ccb7-5&oh=00_AQRa3Zl_viAM914UM1_kQYrqGwPLfpmVqPwlMltzkNd44Q&oe=6AF3871F&_nc_sid=9f8d40",
"followerSourceProfile": "https://www.instagram.com/jupiterhikes/",
"followerSourceProfileId": "1507518892",
"followerSourceProfileUsername": "jupiterhikes",
"followerSourceProfileUrl": "https://www.instagram.com/jupiterhikes/",
"instagramVerified": false,
"instagramPrivate": false
},
{
"instagramUserId": "43861505420",
"instagramUsername": "shivroam",
"instagramFullName": "Shivam Rana I Mountaineer",
"instagramProfileUrl": "https://www.instagram.com/shivroam/",
"instagramPicture": "https://scontent-fra3-1.cdninstagram.com/v/t51.82787-19/858921985_18104766389457421_6701325443259882004_n.jpg?stp=dst-jpg_e0_s150x150_tt6&efg=eyJ2ZW5jb2RlX3RhZyI6InByb2ZpbGVfcGljLmRqYW5nby4xMDgwLmMyIn0&_nc_ht=scontent-fra3-1.cdninstagram.com&_nc_cat=101&_nc_oc=Q6cZ2gGE1JNYkQoszNL29wj7UyG4OGKOarcf_iw1luHzGMllAjP-kLWQ5LQPxtYI3LUcC5g&_nc_ohc=NMw7vs1oyqQQ7kNvwEYvnsx&_nc_gid=ATIykjgJSgaEOBqdAnjQcg&edm=AIfao94BAAAA&ccb=7-5&ig_cache_key=GAEcMjMNkmJpMFJAABTaykn84-9cbmNDAQAB1501500j-ccb7-5&oh=00_AQR5iJXKSUhS5uS8xmmkgeYw-QZ8AbYxVHqIj3guogZgyA&oe=6AF38C8B&_nc_sid=9f8d40",
"followerSourceProfile": "https://www.instagram.com/jupiterhikes/",
"followerSourceProfileId": "1507518892",
"followerSourceProfileUsername": "jupiterhikes",
"followerSourceProfileUrl": "https://www.instagram.com/jupiterhikes/",
"instagramVerified": false,
"instagramPrivate": false
},
{
"instagramUserId": "23413245087",
"instagramUsername": "double24762",
"instagramFullName": "double 佳",
"instagramProfileUrl": "https://www.instagram.com/double24762/",
"instagramPicture": "https://scontent-iad6-1.cdninstagram.com/v/t51.2885-19/573323465_1219825463302212_7278921664109726296_n.png?stp=dst-jpg_e0_s150x150_tt6&efg=eyJ2ZW5jb2RlX3RhZyI6InByb2ZpbGVfcGljLmRqYW5nby4xNTAuYzIifQ&_nc_ht=scontent-iad6-1.cdninstagram.com&_nc_cat=1&_nc_oc=Q6cZ2gH2sHBsdmQY1aWiWoZZWA6eZ603UbEQOH0raGAaH9APRHqzVjuOTqB7gW86Vp6E9Xx44csiK9pjfjrqCVl5R1HC&_nc_ohc=kwiilGbw6cUQ7kNvwHe7b38&edm=AAAAAAABAAAA&ccb=7-5&ig_cache_key=YW5vbnltb3VzX3Byb2ZpbGVfcGlj.3-ccb7-5&oh=00_AQT5TH4G4DvUg9YUXYlVAW4_1Z03ebdjvl84MLuV0umlaQ&oe=6AF37C2A&_nc_sid=328259",
"followerSourceProfile": "https://www.instagram.com/jupiterhikes/",
"followerSourceProfileId": "1507518892",
"followerSourceProfileUsername": "jupiterhikes",
"followerSourceProfileUrl": "https://www.instagram.com/jupiterhikes/",
"instagramVerified": false,
"instagramPrivate": false
}
],
"nextCursor": null
}

Il primo record ha l’ID utente numerico 52256365838, lo username adventuresoforest e i dati pubblici disponibili del profilo. Il suo followerSourceProfileUsername è jupiterhikes, quindi sai quale profilo inviato ha generato la relazione. Il task può essere completato anche quando manca un dato opzionale del profilo. Leggi i campi presenti invece di ricostruire ogni record sulla base di uno schema fisso.

Confronta due audience tramite l’ID utente Instagram

Una volta verificata la richiesta per un singolo profilo, riutilizza scrape_instagram_users() con entrambi i creator in un unico task. Raggruppa le relazioni restituite per ID utente numerico e conserva tutti gli username di origine associati a ciascun ID:

python
comparison_profiles = [
"jupiterhikes",
"https://www.instagram.com/darwin_onthetrail/",
]
comparison_results = scrape_instagram_users(comparison_profiles, api_key)
audience_by_id = {}
collected_count = {}
for result in comparison_results:
source_username = result["followerSourceProfileUsername"]
collected_count[source_username] = collected_count.get(source_username, 0) + 1
user_id = result["instagramUserId"]
grouped_user = audience_by_id.setdefault(
user_id,
{"user": result, "source_profiles": set()},
)
grouped_user["source_profiles"].add(source_username)
overlap = [
{
**grouped_user["user"],
"source_profiles": sorted(grouped_user["source_profiles"]),
}
for grouped_user in audience_by_id.values()
if len(grouped_user["source_profiles"]) == len(comparison_profiles)
]
overlap_report = {
"collected_count": collected_count,
"overlap_count": len(overlap),
"overlap": overlap,
}
print(json.dumps(overlap_report, indent=2, ensure_ascii=False))

Il task con due profili ha restituito 124 relazioni per Jupiter Hikes e 46 per Darwin on the Trail. Tre ID numerici erano presenti in entrambe le liste raccolte. Il task ha consumato 2,7 crediti.

Il codice usa instagramUserId anziché lo username perché l’ID è la chiave di join stabile restituita dall’API. Conserva un oggetto utente API completo e aggiunge una lista source_profiles ordinata. Per ciascuno dei tre ID condivisi, la lista contiene darwin_onthetrail e jupiterhikes.

Per esempio, l’ID numerico 42048393083 compare una volta nei risultati di Jupiter Hikes e una volta in quelli di Darwin on the Trail. Entrambi i record descrivono lo username hikingful, ma ognuno contiene un diverso followerSourceProfileUsername. Il codice raggruppa i due record di relazione in un unico oggetto utente con source_profiles: ["darwin_onthetrail", "jupiterhikes"].

Due liste di follower Instagram unite tramite l’ID utente numerico per individuare la sovrapposizione delle audience, conservando entrambi i profili di origine
Due liste di follower Instagram unite tramite l’ID utente numerico per individuare la sovrapposizione delle audience, conservando entrambi i profili di origine

📘 Interpreta la sovrapposizione con cautela: Un ID condiviso è comparso in entrambi i campioni restituiti. Non misura la sovrapposizione completa delle audience, non dimostra che l’utente segua ancora i creator al momento della pubblicazione e non rende automaticamente l’account idoneo all’outreach.

I valori di collected_count rendono esplicito il denominatore. Se calcoli una percentuale, indicala chiaramente. Per esempio, 3 / 124 esprime gli ID condivisi come percentuale dei record di Jupiter Hikes raccolti in questo task.

Se preferisci uno script locale nel browser, consulta la guida per estrarre gratuitamente follower, profili seguiti e autori dei post di Instagram.

Arricchisci i profili condivisi per analizzare l’audience

La sovrapposizione ti fornisce gli ID numerici di Instagram e la provenienza dei dati. Come passaggio successivo, puoi inviare gli ID condivisi all’enrichment Instagram Profile Scraper e segmentare i risultati riusciti in base a sito web, email pubblica, bio, categoria o metriche del profilo disponibili.

Aggiungi questa seconda funzione sotto quella della source. Utilizza la stessa chiave API e la stessa sequenza di invio, polling e paginazione:

python
def enrich_instagram_profiles(overlap_users, api_key):
"""Recupera i dati pubblici dei profili per gli ID numerici condivisi."""
if not overlap_users:
return []
tasks_url = "https://api.datablist.com/v1/enrichments/tasks"
headers = {"X-API-Key": api_key}
inputs = [
{
"inputId": user["instagramUserId"],
"data": {"instagramIdentifier": user["instagramUserId"]},
}
for user in overlap_users
]
payload = {
"enrichmentId": "instagram-profile-scraper",
"uniqueId": str(uuid.uuid4()),
"settings": {"scrapeType": "profile"},
"inputs": inputs,
}
response = requests.post(tasks_url, headers=headers, json=payload)
response.raise_for_status()
task = response.json()
task_id = task["@id"]
task_url = f"{tasks_url}/{task_id}"
while task["status"] not in ("completed", "failed", "stopped"):
time.sleep(3)
response = requests.get(task_url, headers=headers)
response.raise_for_status()
task = response.json()
if task["status"] != "completed":
raise RuntimeError(
f"Task {task_id} {task['status']}: {task.get('error')}"
)
profile_results = []
params = {"limit": 100}
while True:
response = requests.get(
f"{task_url}/results",
headers=headers,
params=params,
)
response.raise_for_status()
page = response.json()
profile_results.extend(page["results"])
if page["nextCursor"] is None:
break
params["cursor"] = page["nextCursor"]
return profile_results
profile_results = enrich_instagram_profiles(overlap, api_key)
profiles_with_websites = [
result
for result in profile_results
if result["status"] == "success"
and result["outputs"].get("instagramWebsite")
]
profiles_with_public_email = [
result
for result in profile_results
if result["status"] == "success"
and result["outputs"].get("instagramEmail")
]

Se le due liste raccolte non hanno ID in comune, overlap è vuoto e la funzione restituisce [] prima di inviare una richiesta POST. Puoi quindi proseguire con un segmento di ricerca vuoto senza creare un task di enrichment a pagamento.

Usare ogni ID numerico sia come inputId sia come instagramIdentifier rende inequivocabile il join con la sovrapposizione. Conserva tutti gli oggetti restituiti, compresi status non riusciti, output vuoti, consumo di crediti ed errori. Applica i filtri soltanto quando crei un segmento locale.

La modalità profile parte da 2 crediti per ID numerico e può restituire bio pubblica, sito web, email o telefono quando il profilo li espone, oltre a conteggi e categoria. Anche un profilo trovato può avere i campi di contatto vuoti. Il codice prepara localmente i segmenti per la ricerca: non invia messaggi e non considera un follower condiviso come un consenso a essere contattato.

Per eseguire questo passaggio senza codice, usa Instagram Profile Scraper di Datablist.

Passa dai follower ai profili seguiti

La stessa source può recuperare gli account seguiti da un profilo inviato. Modifica soltanto l’argomento scraping_type:

python
following_results = scrape_instagram_users(
["1507518892"],
api_key,
scraping_type="following",
limit_per_profile=100,
)

Questi record descrivono gli account seguiti da Jupiter Hikes. La provenienza viene indicata nei campi followingSourceProfileId, followingSourceProfileUsername e followingSourceProfileUrl. Usa il numero effettivamente restituito, proprio come nella modalità followers.

Calcola il costo dell’API per i follower Instagram

La source dei follower Instagram utilizza 0,01 crediti per ogni follower o profilo seguito restituito. La risoluzione di ciascun profilo di origine inviato può richiedere fino a 1 credito aggiuntivo. La cache può ridurre il costo effettivo.

Per due profili e un limite richiesto di 100 utenti per profilo, la stima è:

2 × (1 + 100 × 0,01) = 4 crediti

Si tratta di una stima, non di un tetto massimo. Il task con due profili ha restituito 170 record di relazione e consumato 2,7 crediti. Al termine dell’esecuzione, leggi task.credits.used per conoscere il costo effettivo.

Loading pricing…

Accesso API, crediti inclusi nel piano, top-up opzionali e consumo dei task sono voci distinte. Il piano mensile Growth costa 50 $ o 50 € e include l’accesso alla REST API e 20.000 crediti al mese. Il top-up minimo attuale aggiunge 20.000 crediti al costo di 20 $ o 17,50 €.

Con queste tariffe di top-up, 1.000 utenti restituiti consumano 10 crediti. Il consumo equivale a 0,01 $ o 0,00875 €, esclusa la risoluzione del profilo di origine. È un valore normalizzato, non un pacchetto acquistabile: il top-up costa comunque 20 $ o 17,50 € e l’accesso API richiede sempre l’abbonamento Growth. Consulta i prezzi aggiornati di Datablist.

Instagram Profile Scraper, opzionale, ha un costo separato. Con un ID numerico e scrapeType: "profile", parte da 2 crediti per ogni profilo condiviso inviato.

Risolvi i problemi più comuni di input e risultati

La chiave API è assente

Lo script genera l’errore Set DATABLIST_API_KEY before running this script. prima di effettuare una richiesta HTTP. Esporta la variabile nella stessa shell ed esegui nuovamente il file.

L’API rifiuta la chiave

response.raise_for_status() genera un errore HTTP. Verifica di aver copiato correttamente la Personal API Key e che il tuo account disponga dell’accesso API del piano Growth. Mantieni l’unico header X-API-Key usato nell’esempio.

Non è possibile risolvere un profilo di origine

Verifica che ogni valore sia uno username, l’URL completo di un profilo Instagram o una stringa contenente un ID utente numerico. Esamina il task esistente e il relativo errore prima di avviare un’altra esecuzione a pagamento.

I crediti non sono sufficienti

Controlla il saldo e riduci il numero di profili o il limite richiesto prima di inviare un altro task. Un task già avviato potrebbe comunque aver consumato crediti.

Il task è failed o stopped

Lo script stampa l’ID del task e genera un RuntimeError. Usa l’ID per esaminare il task esistente, il campo error, credits.used ed eventuali risultati parziali disponibili. Un task failed o stopped può conservare le righe già generate: controllale prima di inviarne un altro.

Il totale restituito non coincide con il limite

Riporta il numero effettivo dei risultati. limitPerProfile è un limite richiesto: non garantisce una quantità esatta e un singolo risultato non permette di capire perché il provider abbia restituito più o meno utenti accessibili.

La risposta all’invio è andata persa

Elenca i task recenti della source e cerca il valore uniqueId stampato prima del POST:

python
unique_id = "paste-the-printed-unique-id"
response = requests.get(
"https://api.datablist.com/v1/sources/tasks",
headers={"X-API-Key": api_key},
params={"sourceId": "instagram-source", "limit": 100},
)
response.raise_for_status()
for task in response.json()["tasks"]:
if task["uniqueId"] == unique_id:
print(task["@id"], task["status"])

Continua il polling di quell’ID oppure recupera i risultati già esistenti. La documentazione sui task delle Sources descrive nel dettaglio gli endpoint per lista, stato, risultati e conservazione.

Prossimi passi

Ora hai una funzione Python Requests riutilizzabile per recuperare le relazioni dei follower Instagram e un report locale che confronta tramite ID utente numerico le liste raccolte per Jupiter Hikes e Darwin on the Trail. Ogni record condiviso conserva entrambi i profili di origine.

Sostituisci gli esempi con una piccola selezione verificata di profili pubblici di creator. Scegli consapevolmente il limite per profilo, quindi interpreta la sovrapposizione in rapporto al numero effettivo restituito per ogni source. Puoi scaricare l’esempio sincrono aggiornato con Requests oppure usare l’esempio asincrono aggiornato con HTTPX quando ti serve una concurrency non bloccante. Se prima devi trovare gli account di origine, parti dalla guida per trovare profili Instagram tramite keyword.