Du kannst Instagram-Follower mit Python scrapen, indem Du einen oder mehrere öffentliche Profilnamen, URLs oder numerische User-IDs über die Requests-Bibliothek an Datablists Instagram Followers Scraper API sendest. Die API gibt die Follower-Datensätze als JSON zurück und zeigt für jede Beziehung das zugehörige Ausgangsprofil an.

Dieser Guide beginnt mit den Followern von Jupiter Hikes, einem Fernwanderer und Filmemacher. Anschließend verwende ich dieselbe Python-Funktion, um seine erfassten Follower mit denen von Darwin on the Trail zu vergleichen, einem weiteren Fernwanderer und Outdoor-Filmemacher. Der Code gruppiert die Ergebnisse nach der numerischen Instagram-User-ID und findet alle User, die in beiden erfassten Listen vorkommen.

🔑 Kurzfassung für Eilige

Mit Datablists Instagram Followers Scraper API kannst Du die Follower öffentlicher Instagram-Profile per Python scrapen. Übermittle die gewünschten Profile, lege ein Limit pro Profil fest und rufe die verfügbaren Follower-Datensätze als JSON für Deine Recherche- oder Marketing-Workflows ab. Prüfe vorab, ob Instagram die Follower-Liste des jeweiligen Profils für Dich zugänglich macht.

  • Input: Instagram-Usernames, Profil-URLs oder numerische User-IDs.
  • Output: Follower-Datensätze mit User-IDs, verfügbaren Profildetails und dem Ausgangsprofil, über das der jeweilige Follower gefunden wurde.

💡 Du bevorzugst eine No-Code-Lösung? Mit Datablists Instagram Followers source erstellst Du Follower-Zeilen ganz ohne Programmierung.

Der Collection-basierte Guide zum Scrapen von Instagram-Followern erklärt dieselbe Source über die Datablist-Oberfläche. Im restlichen Artikel konzentrieren wir uns auf die API.

Prüfen, ob Instagram die Follower-Liste begrenzt

Öffne vor dem Scraping das gewünschte Instagram-Profil und klicke auf Follower. Prüfe, ob Du durch die Follower-Liste scrollen kannst. Auch bei einem öffentlichen Profil ist nicht garantiert, dass Instagram alle Follower anzeigt.

Wenn Du den Hinweis „Nur [username] kann alle Follower sehen“ siehst, liefert der Scraper voraussichtlich nur eine unvollständige Liste – selbst bei einem öffentlichen Profil. Die API kann ausschließlich die Follower abrufen, die Instagram zugänglich macht. Ein höheres angefordertes Limit legt keine verborgenen Follower offen.

Hinweis zur Sichtbarkeit der Follower auf dem Instagram-Profil von Levi’s.
Hinweis zur Sichtbarkeit der Follower auf dem Instagram-Profil von Levi’s.

Prüfe jedes Profil, das Du scrapen möchtest. So weißt Du bereits vor dem API-Request, ob die verfügbare Follower-Liste für Deine Aufgabe ausreicht.

Python und Datablist API-Key einrichten

Der Zugriff auf die Datablist REST API ist im Growth-Plan enthalten. Source-Tasks verbrauchen zusätzlich Credits. Nach dem Walkthrough findest Du eine genaue Aufschlüsselung der Kosten für die Follower-Source.

Erstelle auf Deiner Datablist API-Kontoseite einen Personal API Key. Für dieses Beispiel verwende ich das Paket requests. Erstelle einen Projektordner, öffne ihn im Terminal und führe Folgendes aus:

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

Erstelle eine Datei namens scrape_instagram_followers.py und speichere Deinen Key anschließend in der Umgebungsvariable DATABLIST_API_KEY:

shell
export DATABLIST_API_KEY="your-api-key"

Das Skript liest diese Variable aus und sendet ihren Wert über den Header X-API-Key.

Instagram-Follower mit einer Python-Funktion scrapen

Der erste Request verwendet jupiterhikes, den Username des Fernwanderers und Content Creators Jupiter Hikes. Die Source akzeptiert auch eine vollständige Profil-URL oder eine numerische Instagram-User-ID als String. Die numerische ID von Jupiter Hikes lautet beispielsweise "1507518892".

Füge dieses vollständige Skript in scrape_instagram_followers.py ein:

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,
):
"""Submit profiles, wait for the source task, and return all generated users."""
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))

Führe es so aus:

shell
python scrape_instagram_followers.py

Die Funktion führt nacheinander drei Arten von API-Calls aus.

  1. POST /v1/sources/tasks sendet die Source-ID und die Einstellungen. Die API nimmt den Background-Task an und gibt dessen Task-ID zurück.
  2. GET /v1/sources/tasks/{taskId} prüft den Task alle drei Sekunden. Der Requests-Client wartet, während der Task selbst asynchron in Datablist ausgeführt wird.
  3. GET /v1/sources/tasks/{taskId}/results ruft jeweils eine Seite mit flachen Follower-Objekten ab. Die Schleife übergibt jeden nicht leeren nextCursor unverändert, bis die API null zurückgibt.

Im Beispiel ist scrapingType auf followers gesetzt und über limitPerProfile werden 100 User angefordert. Betrachte diese 100 als gewünschtes Limit, nicht als garantierte Ergebniszahl. Die Seitengrenzen des Providers und die während des Tasks verfügbaren User können die tatsächliche Anzahl beeinflussen.

Das Skript gibt vor dem Absenden die uniqueId aus. Falls die Verbindung während des POST-Requests abbricht, kannst Du mit diesem Wert den bereits angenommenen Task wiederfinden, statt sofort einen weiteren kostenpflichtigen Durchlauf zu starten.

So erstellt die API Follower-Beziehungsdaten

Datablist löst zunächst jeden Username, jede vollständige Profil-URL oder numerische ID zum jeweiligen Instagram-Ausgangsprofil auf. Anschließend ruft ein Background-Task die Follower-Seiten ab und verarbeitet den Cursor des Providers. Du musst lediglich die im Skript gezeigten Cursor für den Datablist-Task und die Ergebnisseiten verwalten.

Wiederholte User-IDs werden innerhalb der zurückgegebenen Liste eines einzelnen Ausgangsprofils dedupliziert. Taucht derselbe User bei zwei übermittelten Creatorn auf, behält die API zwei Beziehungsdatensätze. Sie unterscheiden sich in ihren followerSourceProfile...-Feldern. Genau dadurch wird der Zielgruppenvergleich möglich.

In den nächsten Abschnitten brauchst Du diese Felder:

  • instagramUserId ist der stabile Schlüssel zum Vergleichen der zurückgegebenen User.
  • instagramUsername, instagramFullName und die weiteren instagram...-Felder beschreiben den Follower, sofern die jeweilige öffentliche Angabe verfügbar ist.
  • followerSourceProfileId, followerSourceProfileUsername und followerSourceProfileUrl identifizieren den ursprünglichen Creator.

Diese Source ruft Beziehungslisten ab. Sie sucht weder nach Kandidaten noch berechnet sie Confidence Scores.

Ergebnisse von Jupiter Hikes auswerten

Der abgeschlossene Task für Jupiter Hikes lieferte 124 eindeutige Follower-Datensätze und verbrauchte 2,24 Credits. Obwohl im Request limitPerProfile: 100 angegeben war, lag die laufende Anzahl zunächst bei 99. Danach gab der Provider eine weitere Seite mit 25 Usern zurück. Datablist übernahm diese Seite vollständig, sodass insgesamt 124 Ergebnisse entstanden.

Hier siehst Du die Response der letzten Ergebnisseite. Der Envelope und alle vier Follower-Objekte wurden unverändert übernommen:

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
}

Der erste Datensatz hat die numerische User-ID 52256365838, den Username adventuresoforest und die verfügbaren öffentlichen Profilfelder. Der Wert von followerSourceProfileUsername lautet jupiterhikes. Dadurch weißt Du, welches übermittelte Profil diese Beziehung hervorgebracht hat. Der Task kann auch dann erfolgreich abgeschlossen werden, wenn ein optionaler Profilwert fehlt. Verwende die tatsächlich vorhandenen Felder, statt jeden Datensatz nach einem starren Schema neu aufzubauen.

Zwei Instagram-Zielgruppen per User-ID vergleichen

Sobald der Request mit einem einzelnen Profil funktioniert, verwendest Du scrape_instagram_users() erneut und übergibst beide Hiking-Creator in einem Task. Gruppiere die zurückgegebenen Beziehungen nach der numerischen User-ID und behalte alle mit dieser ID verknüpften Source-Usernames:

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))

Der Task mit zwei Profilen lieferte 124 Follower-Beziehungen für Jupiter Hikes und 46 für Darwin on the Trail. Drei numerische IDs kamen in beiden erfassten Listen vor. Der Task verbrauchte 2,7 Credits.

Der Gruppierungscode verwendet instagramUserId statt des Usernames, weil die ID der stabile Join-Key der API ist. Er behält ein vollständiges User-Objekt aus der API und ergänzt eine sortierte Liste namens source_profiles. Bei jeder der drei gemeinsamen IDs enthält diese Liste darwin_onthetrail und jupiterhikes.

Die numerische ID 42048393083 taucht beispielsweise einmal in den Ergebnissen von Jupiter Hikes und einmal in denen von Darwin on the Trail auf. Beide Datensätze beschreiben den Username hikingful, enthalten aber jeweils einen anderen followerSourceProfileUsername. Der Gruppierungscode verbindet diese beiden Beziehungsdatensätze zu einem User-Objekt mit source_profiles: ["darwin_onthetrail", "jupiterhikes"].

Zwei erfasste Instagram-Follower-Listen werden über numerische User-IDs verbunden, um Überschneidungen zu finden und beide Ausgangsprofile beizubehalten
Zwei erfasste Instagram-Follower-Listen werden über numerische User-IDs verbunden, um Überschneidungen zu finden und beide Ausgangsprofile beizubehalten

📘 Interpretiere die Überschneidung mit Bedacht: Eine gemeinsame ID ist in beiden zurückgegebenen Ausschnitten aufgetaucht. Das Ergebnis misst weder die vollständige Zielgruppenüberschneidung der Creator noch belegt es eine zum Veröffentlichungszeitpunkt bestehende Follow-Beziehung oder qualifiziert den Account automatisch für Outreach.

Die Werte in collected_count machen den Nenner transparent. Wenn Du einen Prozentsatz berechnest, beschrifte ihn eindeutig. So beschreibt 3 / 124 beispielsweise den Anteil der gemeinsamen IDs an den in diesem Task erfassten Datensätzen von Jupiter Hikes.

Wenn Du lieber ein lokales Browser-Skript verwendest, lies den Guide zum kostenlosen Scrapen von Instagram-Followern, Following-Listen und Post-Autoren.

Gemeinsame Profile für die Zielgruppenanalyse anreichern

Die Überschneidung liefert Dir numerische Instagram-IDs samt Herkunft. Als nächsten Schritt kannst Du diese gemeinsamen IDs an das Enrichment Instagram Profile Scraper senden und erfolgreiche Ergebnisse anschließend nach verfügbarer Website, öffentlicher E-Mail-Adresse, Bio, Kategorie oder Profilmetriken segmentieren.

Füge diese zweite Funktion unterhalb der Source-Funktion ein. Sie verwendet denselben API-Key und dieselbe Abfolge aus Absenden, Polling und Pagination:

python
def enrich_instagram_profiles(overlap_users, api_key):
"""Retrieve public profile details for the numeric IDs in the overlap."""
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")
]

Wenn die beiden erfassten Listen keine gemeinsamen IDs enthalten, ist overlap leer und die Funktion gibt [] zurück, bevor sie einen POST-Request sendet. Du kannst mit einem leeren Research-Segment weiterarbeiten, ohne einen kostenpflichtigen Enrichment-Task zu erstellen.

Wenn Du jede numerische ID sowohl als inputId als auch als instagramIdentifier verwendest, lässt sich das Ergebnis eindeutig mit der Überschneidung verknüpfen. Behalte jedes zurückgegebene Ergebnisobjekt – einschließlich nicht erfolgreicher Statuswerte, leerer Outputs, Credit-Verbrauch und Fehler. Filtere erst dann, wenn Du ein lokales Segment erstellst.

Der Modus profile kostet ab 2 Credits pro numerischer ID. Er kann eine öffentliche Bio, Website, E-Mail-Adresse oder Telefonnummer sowie Profilzahlen und Kategoriedetails zurückgeben, sofern das Profil diese Angaben offenlegt. Auch bei einem gefundenen Profil können die Kontaktfelder leer sein. Der Code erstellt lokale Research-Segmente. Er versendet keine Nachrichten und wertet einen gemeinsamen Follower nicht als Zustimmung zur Kontaktaufnahme.

Für eine No-Code-Version dieses Schritts kannst Du Datablists Instagram Profile Scraper verwenden.

Von Followern zu Following wechseln

Dieselbe Source kann die Accounts abrufen, denen ein übermitteltes Profil folgt. Ändere dafür nur das Argument scraping_type:

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

Diese Datensätze beschreiben die Accounts, denen Jupiter Hikes folgt. Die Herkunft steht dann in followingSourceProfileId, followingSourceProfileUsername und followingSourceProfileUrl. Verwende wie im Follower-Modus die tatsächlich zurückgegebene Anzahl.

Kosten der Instagram Follower API kalkulieren

Die Instagram-Follower-Source verbraucht 0,01 Credits für jeden zurückgegebenen Follower oder Following-User. Das Auflösen eines übermittelten Ausgangsprofils kann bis zu 1 zusätzlichen Credit kosten. Durch zwischengespeicherte Auflösungen können die tatsächlichen Kosten niedriger ausfallen.

Für zwei Profile mit einem gewünschten Limit von jeweils 100 Usern ergibt sich folgende Planungsschätzung:

2 × (1 + 100 × 0.01) = 4 Credits

Das ist eine Schätzung, keine Obergrenze. Der Task mit zwei Profilen lieferte 170 Beziehungsdatensätze und verbrauchte 2,7 Credits. Den tatsächlichen Verbrauch findest Du nach dem Durchlauf unter task.credits.used.

Loading pricing…

API-Zugriff, enthaltene Plan-Credits, optionale Top-ups und Task-Verbrauch sind separate Posten. Der monatliche Growth-Plan kostet 50 $ oder 50 € und umfasst den Zugriff auf die REST API sowie 20.000 Credits pro Monat. Das derzeit kleinste Top-up bietet weitere 20.000 Credits für 20 $ oder 17,50 €.

Bei diesen Top-up-Preisen verbrauchen 1.000 zurückgegebene User 10 Credits. Das entspricht einem Nutzungswert von 0,01 $ oder 0,00875 €, bevor die Auflösung der Ausgangsprofile berücksichtigt wird. Dieser normierte Wert ist kein separat erhältliches Paket: Das Top-up kostet weiterhin 20 $ oder 17,50 €, und für den API-Zugriff ist weiterhin das Growth-Abo erforderlich. Die aktuellen Angebote findest Du auf der Seite mit den Datablist-Preisen.

Der optionale Instagram Profile Scraper hat ein eigenes Preismodell. Mit einer numerischen ID und scrapeType: "profile" kostet er ab 2 Credits pro übermitteltem Überschneidungsprofil.

Häufige Probleme mit Inputs, Tasks und Ergebnissen lösen

Der API-Key fehlt

Das Skript löst vor einem HTTP-Request den Fehler Set DATABLIST_API_KEY before running this script. aus. Exportiere die Variable in derselben Shell und führe die Datei erneut aus.

Die API lehnt den Key ab

response.raise_for_status() löst einen HTTP-Fehler aus. Prüfe, ob Du den Personal API Key korrekt kopiert hast und Dein Account über den API-Zugriff des Growth-Plans verfügt. Verwende ausschließlich den im Beispiel gezeigten Header X-API-Key.

Ein Ausgangsprofil lässt sich nicht auflösen

Prüfe, ob jeder Wert ein Username, eine vollständige Instagram-Profil-URL oder eine numerische User-ID als String ist. Sieh Dir den bestehenden Task und dessen Fehler an, bevor Du einen weiteren kostenpflichtigen Durchlauf erstellst.

Die Credits reichen nicht aus

Prüfe Dein Guthaben und reduziere die Anzahl der Profile oder das gewünschte Limit, bevor Du einen weiteren Task absendest. Ein bereits gestarteter Task kann trotzdem Credits verbraucht haben.

Der Task ist fehlgeschlagen oder wurde gestoppt

Das Skript gibt die Task-ID aus und löst einen RuntimeError aus. Verwende diese ID, um den bestehenden Task, dessen error, credits.used und alle verfügbaren Teilergebnisse zu prüfen. Auch bei einem fehlgeschlagenen oder gestoppten Task können bereits erzeugte Zeilen erhalten bleiben. Prüfe sie daher, bevor Du einen neuen Task absendest.

Die Ergebniszahl weicht vom gewünschten Limit ab

Gib die tatsächliche Anzahl der Ergebnisse an. limitPerProfile ist ein gewünschtes Limit und garantiert keine exakte Zahl. Aus einem einzelnen Ergebnis lässt sich außerdem nicht ableiten, warum der Provider mehr oder weniger zugängliche User zurückgegeben hat.

Die Response beim Absenden ging verloren

Rufe Deine letzten Source-Tasks ab und suche nach der uniqueId, die vor dem POST-Request ausgegeben wurde:

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"])

Setze das Polling mit dieser Task-ID fort oder rufe die bereits vorhandenen Ergebnisse ab. Die Dokumentation zu Source-Tasks beschreibt die Endpoints für Listen, Status, Ergebnisse und Aufbewahrung im Detail.

Nächste Schritte

Du hast jetzt eine wiederverwendbare Python-Requests-Funktion, die Instagram-Follower-Beziehungen abruft, sowie einen lokalen Report, der die erfassten Listen von Jupiter Hikes und Darwin on the Trail anhand numerischer User-IDs vergleicht. Jeder gemeinsame Datensatz behält beide Ausgangsprofile bei.

Ersetze die Beispiele durch eine kleine, sorgfältig geprüfte Auswahl öffentlicher Creator-Profile. Lege bewusst ein Limit pro Profil fest und bewerte die Überschneidung anhand der tatsächlich für jede Source zurückgegebenen Anzahl. Du kannst das gepflegte synchrone Requests-Beispiel herunterladen oder das gepflegte asynchrone HTTPX-Beispiel verwenden, wenn Du nicht blockierende parallele Requests benötigst. Falls Du zunächst passende Ausgangsaccounts finden musst, beginne mit dem Guide zum Finden von Instagram-Profilen über Keywords.