# Kontroll av Instagram-profiler før en reklamekampanje: avviksrapport i Python

https://jsonscraper.com/no/blog/kontroller-instagram-profiler-for-kampanje

Author: Michael Johnson

Published: 2026-11-19T11:41:13+00:00

Updated: 2026-11-19T11:41:13+00:00

Hent offentlig profilinformasjon fra kontoene i briefen, og lag en avvikstabell før kampanjen starter

Ved å kontrollere Instagram-kontoer før kampanjen starter kan du finne feil i listen over plasseringer mens de fortsatt er enkle å rette. Briefen kan for eksempel inneholde en skrivefeil i et brukernavn, en konto som er oppført flere ganger eller en profil med et uventet antall følgere. Nedenfor finner du et lite Python-skript som henter offentlige data for hvert brukernavn, sammenligner svaret med kravene dine og lagrer kontrollerbare rader i en CSV-fil.

 

## Dette får du

 

Som inndata brukes en CSV-fil med en liste over kontoer og valgfrie forventede verdier. Resultatet er én egen rad for hvert behandlede brukernavn: forespørselsstatus, profilnavn, verifiseringsmerke, antall følgere, innlegg og kontoer som følges, samt en kort liste over avvik som er funnet.



![Artikkel: Kontroll av Instagram-profiler før en reklamekampanje: avviksrapport i Python
Sammendrag: Hvis briefen inneholder feil kontonavn, ekstra mellomrom eller en uegnet profil, kan teamet oppdage det først etter at kampanjen er klargjort. Slik kontrollerer du Instagram-brukernavn via jsonscrapers dokumenterte endepunkt og eksporterer observerte avvik til CSV.
Bildets rolle: omslagsbilde – hovedideen
Del: Dette får du
Visuelt motiv: redaksjonelt bilde «»](https://jsonscraper.com/assets/uploads/journal/2026/11/84aacded9a89d423a6289b53b549643f.png.hero.webp)

Rapporten samler kontrollerte profilopplysninger og merknader til manuell gjennomgang før kampanjestart.© jsonscraper · laget med KI

 

En slik rapport er nyttig for markedsføreren som kontrollerer leverandører opp mot briefen, og for utvikleren som setter opp en intern kontroll som en gjentakende oppgave. Dette er en kontroll av bestemte offentlige profilopplysninger på forespørselstidspunktet; teamet må fortsatt selv avgjøre om profilen passer til kampanjen.

 

## Hvilke opplysninger kan kontrolleres

 

Den dokumenterte ruten i Instagram API-et `/v1/user/by/username` krever parameteren `username`. I det observerte svarformatet ligger profildataene i objektet `ig`; blant feltene som ble returnert, var `username`, `full_name`, `is_private`, `is_verified`, `media_count`, `follower_count`, `following_count` og `biography`. Hvilke felt som finnes, kan variere. Derfor registrerer skriptet manglende verdier som tomme, uten å gjøre dem om til null. En liste over ruter og parameternavn finnes i [referansen for Instagram API-et](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md).

 

Kontrollen er særlig nyttig for krav som kan uttrykkes tydelig: Profilen skal være offentlig, antallet følgere skal ligge innenfor et angitt intervall, og verifiseringsmerket skal samsvare med kravet i briefen. Biografien kan lagres for senere gjennomgang, men automatisk sammenligning av teksten med markedsføringsposisjoneringen krever et eget kriterium.

 

## Klargjør inndatafilen

 

Opprett `profiles.csv` i UTF-8. Den enkleste varianten inneholder bare brukernavn; la ekstra forventede felt stå tomme hvis briefen ikke stiller slike krav:

 

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

 

Verdiene `min_followers` og `max_followers` angir grensene som skal kontrolleres. Feltet `verified` godtar `true` eller `false`. Du kan angi bare de kravene som gjelder for hver profil.

 

## Hent data og lag rapporten

 

Installer `requests`, og angi nøkkelen i prosessens miljøvariabler, ikke i kildefilen. På macOS eller Linux ser kommandoen slik ut:



![Artikkel: Kontroll av Instagram-profiler før en reklamekampanje: avviksrapport i Python
Sammendrag: Hvis briefen inneholder feil kontonavn, ekstra mellomrom eller en uegnet profil, kan teamet oppdage det først etter at kampanjen er klargjort. Slik kontrollerer du Instagram-brukernavn via jsonscrapers dokumenterte endepunkt og eksporterer observerte avvik til CSV.
Bildets rolle: støtteillustrasjon 2 – et annet konkret aspekt
Del: Hent data og lag rapporten
Visuelt motiv:» loading=](https://jsonscraper.com/assets/uploads/journal/2026/11/146a636928d29c035050cacd0aa101b8.png.hero.webp)

Diagrammet viser veien fra en CSV med kontolisten til en rapport der tomme felt forblir tomme og treff på reglene markeres separat.© jsonscraper · KI-generert illustrasjon

 

```
python -m pip install requests
export JSONSCRAPER_INSTAGRAM_LICENSE_KEY='din-nøkkel'
```

 

Lagre skriptet nedenfor som `check_profiles.py`. Det bruker Python 3.8+, kontrollerer den eksterne svarstatusen, leser nyttelasten `ig` separat og oppretter `profile_check.csv`. Nøkkelen sendes som query-parameteren `license_key`, slik tjenestens dokumentasjon angir.

 

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

 

## Slik leser du rader med avvik

 

Kjør `python check_profiles.py`. Verdien `ok` i kolonnen `status` betyr at skriptet mottok det forventede profilobjektet og kunne opprette en rad. Kolonnen `issues` inneholder bare resultatene av de kontrollerte reglene, for eksempel `private_profile` eller `below_min_followers`. En tom kolonne betyr at de angitte vilkårene ikke avdekket avvik; det bekrefter ikke innholdskvaliteten eller at andre punkter i avtalen er oppfylt.

 

Sammenlign `returned_username` med det opprinnelige brukernavnet, og send `biography` og `full_name` til en ansvarlig medarbeider for en innholdsmessig vurdering. Rapporten inkluderer også forespørselsfeil, uventet API-status og manglende `ig`-objekt. Slike rader blir stående i utvalget, slik at du kan skille en teknisk feil fra resultatet av kontrollen.

 

## Slik kjører du kontrollen regelmessig

 

For en engangskontroll holder det å kjøre skriptet manuelt. I en gjentakende prosess kan du legge det til i en planlegger eller CI-arbeidsflyt: last inn en oppdatert liste, utfør forespørslene, lagre CSV-filen som et artefakt og varsle teamet hvis kolonnen `issues` inneholder verdier. Ikke skriv nøkkelen til logger; oppbevar den som en hemmelighet i kjøremiljøet.

 

Hvis du kontrollerer de samme profilene ofte, kan du angi parameteren `cache_timeout` som antall sekunder dataene skal mellomlagres. Dokumentasjonen opplyser at mellomlagring for Instagram er slått av som standard; en verdi over null aktiverer den for den angitte perioden. Legg bare til parameteren hvis det er greit å bruke svaret på nytt innenfor det valgte tidsintervallet.

 

Kontroller bare data og scenarier du har rett til å bruke. Bruk resultatet som et øyeblikksbilde av et bestemt API-svar, noter datoen for kjøringen i din egen logg, og gjennomgå tersklene sammen med briefen. Du finner detaljer om ruten, tilgjengelige felt og integreringsalternativer på siden for [Instagram Scraper API](https://jsonscraper.com/services/ig-scraper-api) og i [den offisielle dokumentasjonen for endepunktet](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md).
