# Instagram-profielen controleren vóór een advertentiecampagne: een afwijkingenrapport met Python

https://jsonscraper.com/nl/blog/instagram-profielen-controleren-advertentiecampagne-python

Author: Michael Johnson

Published: 2026-11-19T11:39:16+00:00

Updated: 2026-11-19T11:39:16+00:00

Haal openbare accountgegevens uit een briefing op en maak vóór de start van de campagne een overzicht van afwijkingen

Instagram-accounts controleren vóór de start van een campagne helpt fouten in de plaatsingslijst op te sporen zolang ze nog eenvoudig te verhelpen zijn. Een briefing kan bijvoorbeeld een typefout in een gebruikersnaam, een dubbel account of een profiel met een onverwacht aantal volgers bevatten. Hieronder staat een klein Python-script dat openbare gegevens voor elke gebruikersnaam opvraagt, het antwoord met je voorwaarden vergelijkt en de controleerbare regels in een CSV-bestand opslaat.

 

## Wat het resultaat oplevert

 

Als invoer gebruik je een CSV-bestand met een lijst accounts en optionele verwachte waarden. Het resultaat is één regel voor elke verwerkte gebruikersnaam: de aanvraagstatus, profielnaam, verificatiestatus, het aantal volgers, berichten en gevolgde accounts, plus een korte lijst met gevonden afwijkingen.



![Artikel: Instagram-profielen controleren vóór een advertentiecampagne: een afwijkingenrapport met Python
Samenvatting: Als een briefing onjuiste accountnamen, extra spaties of een ongeschikt profiel bevat, ontdekt het team dat mogelijk pas nadat de campagne is voorbereid. We laten zien hoe je Instagram-gebruikersnamen controleert via het gedocumenteerde jsonscraper-endpoint en waargenomen afwijkingen exporteert naar CSV.
Afbeeldingsrol: omslag — het centrale idee
Sectie: Wat het resultaat oplevert
Visueel onderwerp: redactionele foto ](https://jsonscraper.com/assets/uploads/journal/2026/11/84aacded9a89d423a6289b53b549643f.png.hero.webp)

Het rapport brengt gecontroleerde profielvelden en aandachtspunten voor handmatige controle vóór de start van de campagne samen.© jsonscraper · gemaakt met AI

 

Zo'n rapport is handig voor een marketeer die partners aan de briefing toetst, en voor een ontwikkelaar die een interne controle als terugkerende taak inricht. Het controleert specifieke openbare profielvelden op het moment van de aanvraag; het team blijft zelf verantwoordelijk voor de uiteindelijke beslissing over de geschiktheid voor de campagne.

 

## Welke velden je kunt controleren

 

De gedocumenteerde Instagram API-route `/v1/user/by/username` vereist de parameter `username`. In de waargenomen antwoordstructuur staan profielgegevens in het object `ig`; de geretourneerde velden omvatten `username`, `full_name`, `is_private`, `is_verified`, `media_count`, `follower_count`, `following_count` en `biography`. Welke velden aanwezig zijn, kan verschillen. Daarom schrijft het script hieronder ontbrekende waarden als leeg weg en zet het ze niet om in nul. De lijst met routes en parameternamen staat in de [Instagram API-handleiding](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md).

 

De controle is vooral overzichtelijk voor voorwaarden die je expliciet kunt vastleggen: het profiel moet openbaar zijn, het aantal volgers moet binnen een opgegeven bereik vallen en de verificatiestatus moet overeenkomen met de briefing. Je kunt de biografie bewaren om die later te bekijken, maar voor een automatische vergelijking van de tekst met de marketingpositionering is een afzonderlijk criterium nodig.

 

## Bereid het invoerbestand voor

 

Maak een UTF-8-bestand met de naam `profiles.csv`. De minimale versie bevat alleen gebruikersnamen; laat aanvullende verwachte velden leeg als de briefing daar geen eisen aan stelt:

 

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

 

De waarden `min_followers` en `max_followers` bepalen de grenzen voor de controle. Het veld `verified` accepteert `true` of `false`. Je kunt per profiel alleen de voorwaarden invullen die van toepassing zijn.

 

## Vraag gegevens op en maak het rapport

 

Installeer `requests` en stel de sleutel in als omgevingsvariabele van het proces, niet in het bronbestand. Op macOS of Linux ziet de opdracht er zo uit:



![Artikel: Instagram-profielen controleren vóór een advertentiecampagne: een afwijkingenrapport met Python
Samenvatting: Als een briefing onjuiste accountnamen, extra spaties of een ongeschikt profiel bevat, ontdekt het team dat mogelijk pas nadat de campagne is voorbereid. We laten zien hoe je Instagram-gebruikersnamen controleert via het gedocumenteerde jsonscraper-endpoint en waargenomen afwijkingen exporteert naar CSV.
Afbeeldingsrol: ondersteunende illustratie 2 — een ander specifiek aspect
Sectie: Vraag gegevens op en maak](https://jsonscraper.com/assets/uploads/journal/2026/11/146a636928d29c035050cacd0aa101b8.png.hero.webp)

Het schema toont de route van een CSV met accounts naar een rapport waarin lege velden leeg blijven en overeenkomsten met regels afzonderlijk worden gemarkeerd.© jsonscraper · AI-gegenereerde illustratie

 

```
python -m pip install requests
export JSONSCRAPER_INSTAGRAM_LICENSE_KEY='uw-sleutel'
```

 

Sla het onderstaande script op als `check_profiles.py`. Het gebruikt Python 3.8 of hoger, controleert de externe antwoordstatus, leest de gegevens uit `ig` afzonderlijk uit en maakt `profile_check.csv`. De sleutel wordt als queryparameter `license_key` doorgegeven, zoals beschreven in de documentatie van de dienst.

 

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


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"Verwerkte regels: {len(output)}; rapport: profile_check.csv")
```

 

## Regels met afwijkingen lezen

 

Start het script met `python check_profiles.py`. In de kolom `status` betekent `ok` dat het script het verwachte profielobject heeft ontvangen en een regel heeft kunnen aanmaken. De kolom `issues` bevat alleen gecontroleerde regels, zoals `private_profile` of `below_min_followers`. Een lege kolom betekent dat de vastgelegde voorwaarden geen afwijkingen hebben opgeleverd; dat bevestigt niet de kwaliteit van de inhoud of de naleving van andere contractuele eisen.

 

Vergelijk `returned_username` met de oorspronkelijke gebruikersnaam en laat een verantwoordelijke medewerker `biography` en `full_name` inhoudelijk controleren. Het rapport bevat ook aanvraagfouten, een onverwachte API-status en ontbrekende `ig`-objecten. Zulke regels blijven in de uitvoer staan en helpen een technische storing te onderscheiden van een controleresultaat.

 

## De controle regelmatig uitvoeren

 

Voor een eenmalige controle volstaat het om het script handmatig te starten. Voeg het in een terugkerend proces toe aan een planner of CI-workflow: laad de actuele lijst, voer de aanvragen uit, bewaar de CSV als artefact en waarschuw het team als de kolom `issues` waarden bevat. Schrijf de sleutel niet naar logs; bewaar die als geheim in de runtime-omgeving.

 

Als je dezelfde profielen vaak controleert, kun je `cache_timeout` meegeven als het aantal seconden dat resultaten in de cache blijven. Volgens de documentatie staat caching voor Instagram standaard uit; een waarde groter dan nul schakelt caching in voor de opgegeven periode. Voeg deze parameter alleen toe als het acceptabel is om een antwoord binnen het gekozen interval opnieuw te gebruiken.

 

Controleer alleen gegevens en scenario's waarvoor je toestemming hebt. Gebruik het resultaat als momentopname van een specifiek API-antwoord, noteer de uitvoerdatum in je eigen logboek en beoordeel de drempelwaarden opnieuw aan de hand van de briefing. Details over de route, beschikbare velden en integratiemogelijkheden vind je op de pagina [Instagram Scraper API](https://jsonscraper.com/services/ig-scraper-api) en in de [officiële endpointdocumentatie](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md).
