# Kontrollera Instagram-profiler inför en kampanj med Python

https://jsonscraper.com/sv/blog/kontrollera-instagram-profiler-infor-kampanj

Author: Michael Johnson

Published: 2026-11-19T11:42:21+00:00

Updated: 2026-11-19T11:42:21+00:00

Hämta offentliga uppgifter om konton från briefen och skapa en avvikelserapport innan kampanjen startar

Genom att kontrollera Instagram-konton innan kampanjen startar kan du hitta fel i placeringslistan medan de fortfarande är lätta att rätta till. Briefen kan till exempel innehålla ett felstavat namn, ett konto som förekommer två gånger eller en profil med oväntat antal följare. Nedan finns ett litet Python-skript som hämtar offentliga uppgifter för varje användarnamn, jämför svaret med dina kriterier och sparar kontrollerbara rader i en CSV-fil.

 

## Det här får du

 

Indata är en CSV-fil med en lista över konton och eventuella förväntade värden. Resultatet är en separat rad för varje behandlat användarnamn: förfrågans status, profilnamn, verifieringsmarkering, antal följare, inlägg och följningar samt en kort lista över upptäckta avvikelser.



![Artikel: Kontrollera Instagram-profiler inför en kampanj med Python
Sammanfattning: Felaktiga kontonamn, extra blanksteg eller en olämplig profil i briefen kan upptäckas först när kampanjen redan har förberetts. Så här kontrollerar du Instagram-användarnamn via den dokumenterade jsonscraper-endpointen och exporterar observerade avvikelser till CSV.
Bildens roll: omslagsbild – huvudidén
Avsnitt: Det här får du
Visuellt motiv: redaktionellt foto ](https://jsonscraper.com/assets/uploads/journal/2026/11/84aacded9a89d423a6289b53b549643f.png.hero.webp)

Rapporten sammanställer kontrollerade profilfält och markeringar för manuell granskning före kampanjstart.© jsonscraper · skapad med AI

 

En sådan rapport är användbar för marknadsförare som stämmer av samarbetspartner mot briefen och för utvecklare som bygger in en regelbunden intern kontroll. Det här är en kontroll av specifika offentliga profilfält vid tidpunkten för förfrågan; teamet ansvarar fortfarande för det manuella beslutet om profilen passar kampanjen.

 

## Fält som kan kontrolleras

 

Den dokumenterade rutten i Instagram API, `/v1/user/by/username`, tar emot den obligatoriska parametern `username`. I det observerade svarsformatet finns profildata i objektet `ig`; fälten som förekom var `username`, `full_name`, `is_private`, `is_verified`, `media_count`, `follower_count`, `following_count` och `biography`. Fält kan saknas, så skriptet nedan skriver dem som tomma i stället för att omvandla dem till noll. En lista över rutter och parameternamn finns i [Instagram API-referensen](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md).

 

Kontrollen är särskilt tydlig för villkor som går att uttrycka konkret: profilen ska vara offentlig, antalet följare ska ligga inom ett angivet intervall och verifieringsmarkeringen ska motsvara briefens krav. Biografin kan sparas för senare granskning, men automatisk jämförelse av texten med marknadsföringens positionering kräver ett separat kriterium.

 

## Förbered indatafilen

 

Skapa `profiles.csv` i UTF-8. Den enklaste varianten innehåller endast användarnamn; lämna övriga förväntade fält tomma om briefen inte anger några begränsningar:

 

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

 

Värdena `min_followers` och `max_followers` anger gränserna för kontrollen. Fältet `verified` tar emot `true` eller `false`. Ange endast de villkor som gäller för respektive profil.

 

## Hämta uppgifter och skapa rapporten

 

Installera `requests` och ange nyckeln i processens miljö, inte i källfilen. På macOS eller Linux ser kommandot ut så här:



![Artikel: Kontrollera Instagram-profiler inför en kampanj med Python
Sammanfattning: Felaktiga kontonamn, extra blanksteg eller en olämplig profil i briefen kan upptäckas först när kampanjen redan har förberetts. Så här kontrollerar du Instagram-användarnamn via den dokumenterade jsonscraper-endpointen och exporterar observerade avvikelser till CSV.
Bildens roll: stödillustration 2 – en annan specifik aspekt
Avsnitt: Hämta uppgifter och skapa rappor](https://jsonscraper.com/assets/uploads/journal/2026/11/146a636928d29c035050cacd0aa101b8.png.hero.webp)

Diagrammet visar flödet från en CSV med kontolista till en rapport där tomma fält förblir tomma och matchningar mot regler markeras separat.© jsonscraper · AI-genererad illustration

 

```
python -m pip install requests
export JSONSCRAPER_INSTAGRAM_LICENSE_KEY='din-nyckel'
```

 

Spara skriptet nedan som `check_profiles.py`. Det använder Python 3.8+, kontrollerar HTTP-svarets status, läser nyttolasten `ig` separat och skapar `profile_check.csv`. Nyckeln skickas som frågeparameter `license_key`, enligt tjänstens dokumentation.

 

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

 

## Så läser du rader med avvikelser

 

Kör `python check_profiles.py`. I kolumnen `status` betyder värdet `ok` att skriptet fick det förväntade profilobjektet och kunde skapa en post. Kolumnen `issues` innehåller endast kontrollerade regler, till exempel `private_profile` eller `below_min_followers`. En tom kolumn betyder att de angivna villkoren inte visade någon avvikelse; den bekräftar inte innehållets kvalitet eller att andra punkter i avtalet är uppfyllda.

 

Jämför `returned_username` med det ursprungliga användarnamnet och låt en ansvarig medarbetare granska `biography` och `full_name` manuellt. Rapporten innehåller även förfrågningsfel, oväntad API-status och saknat `ig`-objekt. Sådana rader finns kvar i urvalet och gör det lättare att skilja ett tekniskt fel från ett kontrollresultat.

 

## Så kör du kontrollen regelbundet

 

För en engångskontroll räcker det att köra skriptet manuellt. I en återkommande process kan du lägga till det i en schemaläggare eller ett CI-arbetsflöde: läs in den aktuella listan, skicka förfrågningarna, spara CSV-filen som en artefakt och meddela teamet om kolumnen `issues` innehåller värden. Skriv inte ut nyckeln i loggar; lagra den som en hemlighet i körmiljön.

 

Om du ofta kontrollerar samma profiler kan parametern `cache_timeout` anges som antal sekunder för cachelagring. Dokumentationen anger att cachelagring för Instagram är avstängd som standard; ett värde större än noll aktiverar den under den angivna perioden. Lägg bara till parametern om det är acceptabelt att återanvända ett svar inom det valda tidsintervallet.

 

Kontrollera endast uppgifter och scenarier som du har rätt att använda. Behandla resultatet som en ögonblicksbild av ett specifikt API-svar, dokumentera kördatumet i en egen logg och se över tröskelvärdena tillsammans med briefen. Mer information om rutter, tillgängliga fält och integrationsalternativ finns på sidan [Instagram Scraper API](https://jsonscraper.com/services/ig-scraper-api) och i [den officiella endpoint-dokumentationen](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md).
