# Weryfikacja profili na Instagramie przed kampanią reklamową: raport rozbieżności w Pythonie

https://jsonscraper.com/pl/blog/weryfikacja-profili-instagram-przed-kampania

Author: Michael Johnson

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

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

Pobierz publiczne informacje o kontach z briefu i utwórz tabelę wyjątków przed rozpoczęciem kampanii

Weryfikacja kont na Instagramie przed rozpoczęciem kampanii pomaga znaleźć błędy na liście publikacji, gdy można je jeszcze łatwo poprawić. Brief może na przykład zawierać literówkę w nazwie, powtórzone konto albo profil z nieoczekiwaną liczbą obserwujących. Poniżej przedstawiamy krótki skrypt w Pythonie, który pobiera publiczne dane dla każdej nazwy użytkownika, porównuje odpowiedź z określonymi przez Ciebie warunkami i zapisuje weryfikowalne wiersze do pliku CSV.

 

## Jaki będzie wynik

 

Na wejściu znajduje się plik CSV z listą kont i opcjonalnymi oczekiwanymi wartościami. Wynikiem jest osobny wiersz dla każdej przetworzonej nazwy użytkownika: status żądania, nazwa profilu, oznaczenie weryfikacji, liczba obserwujących, publikacji i obserwowanych, a także krótka lista wykrytych rozbieżności.



![Artykuł: Weryfikacja profili na Instagramie przed kampanią reklamową: raport rozbieżności w Pythonie
Podsumowanie: Błędne nazwy kont, dodatkowe spacje lub niewłaściwy profil w briefie mogą zostać wykryte dopiero po przygotowaniu kampanii. Pokazujemy, jak sprawdzić nazwy użytkowników Instagrama za pomocą udokumentowanego endpointu jsonscraper i wyeksportować zaobserwowane rozbieżności do pliku CSV.
Rola obrazu: okładka — główna idea
Sekcja: Jaki będzie wynik
Temat wizualny: zdjęcie redakcyjne ](https://jsonscraper.com/assets/uploads/journal/2026/11/84aacded9a89d423a6289b53b549643f.png.hero.webp)

Raport zestawia sprawdzone pola profilu i uwagi wymagające ręcznej weryfikacji przed rozpoczęciem kampanii.© jsonscraper · utworzono z użyciem AI

 

Taki raport przyda się marketerowi porównującemu wykonawców z briefem oraz programiście wdrażającemu wewnętrzną kontrolę jako regularne zadanie. Jest to kontrola konkretnych pól profilu publicznego w chwili wysłania żądania; ostateczna decyzja, czy profil spełnia wymagania kampanii, należy do zespołu.

 

## Jakie pola można sprawdzić

 

Udokumentowana ścieżka Instagram API `/v1/user/by/username` wymaga parametru `username`. W zaobserwowanym formacie odpowiedzi dane profilu znajdują się w obiekcie `ig`; wśród zwracanych pól były `username`, `full_name`, `is_private`, `is_verified`, `media_count`, `follower_count`, `following_count` i `biography`. Dostępność pól może się różnić, dlatego poniższy skrypt zapisuje brakujące wartości jako puste, zamiast zamieniać je na zero. Lista ścieżek i nazw parametrów znajduje się w [dokumentacji Instagram API](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md).

 

Kontrola jest szczególnie przydatna w przypadku warunków, które można jasno określić: profil ma być publiczny, liczba obserwujących musi mieścić się w zadanym zakresie, a oznaczenie weryfikacji powinno być zgodne z wymaganiami briefu. Biografię można zapisać do późniejszego przeglądu, ale automatyczne porównanie tekstu z pozycjonowaniem marketingowym wymaga osobnego kryterium.

 

## Przygotuj plik wejściowy

 

Utwórz plik `profiles.csv` w kodowaniu UTF-8. Minimalna wersja zawiera tylko nazwę użytkownika; dodatkowe oczekiwane pola pozostaw puste, jeśli brief nie określa danego ograniczenia:

 

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

 

Wartości `min_followers` i `max_followers` określają granice kontroli. Pole `verified` przyjmuje wartość `true` lub `false`. Dla każdego profilu można podać tylko te warunki, które mają zastosowanie.

 

## Pobierz dane i utwórz raport

 

Zainstaluj `requests` i ustaw klucz w środowisku procesu, a nie w pliku źródłowym. W systemach macOS lub Linux użyj poleceń:



![Artykuł: Weryfikacja profili na Instagramie przed kampanią reklamową: raport rozbieżności w Pythonie
Podsumowanie: Błędne nazwy kont, dodatkowe spacje lub niewłaściwy profil w briefie mogą zostać wykryte dopiero po przygotowaniu kampanii. Pokazujemy, jak sprawdzić nazwy użytkowników Instagrama za pomocą udokumentowanego endpointu jsonscraper i wyeksportować zaobserwowane rozbieżności do pliku CSV.
Rola obrazu: ilustracja uzupełniająca 2 — inny konkretny aspekt
Sekcja: Pobierz dane i utwórz r](https://jsonscraper.com/assets/uploads/journal/2026/11/146a636928d29c035050cacd0aa101b8.png.hero.webp)

Schemat przedstawia drogę od pliku CSV z listą kont do raportu, w którym puste pola pozostają puste, a zgodność z regułami jest oznaczana osobno.© jsonscraper · ilustracja wygenerowana przez AI

 

```
python -m pip install requests
export JSONSCRAPER_INSTAGRAM_LICENSE_KEY='twój-klucz'
```

 

Zapisz poniższy skrypt jako `check_profiles.py`. Wymaga Pythona 3.8 lub nowszego, sprawdza zewnętrzny status odpowiedzi, osobno odczytuje ładunek danych `ig` i tworzy plik `profile_check.csv`. Klucz jest przekazywany jako parametr zapytania `license_key`, zgodnie z dokumentacją usługi.

 

```
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("Ustaw 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"Przetworzone wiersze: {len(output)}; raport: profile_check.csv")
```

 

## Jak czytać wiersze z rozbieżnościami

 

Uruchom `python check_profiles.py`. W kolumnie `status` wartość `ok` oznacza, że skrypt otrzymał oczekiwany obiekt profilu i mógł utworzyć rekord. Kolumna `issues` zawiera wyłącznie wyniki sprawdzonych reguł, na przykład `private_profile` lub `below_min_followers`. Pusta kolumna oznacza, że określone warunki nie wykazały rozbieżności; nie potwierdza jakości treści ani zgodności z innymi punktami umowy.

 

Porównaj `returned_username` z początkową nazwą użytkownika, a pola `biography` i `full_name` przekaż odpowiedzialnej osobie do oceny merytorycznej. W raporcie znajdą się także błędy żądań, nieoczekiwany status API oraz brak obiektu `ig`: takie wiersze pozostają w wynikach i pomagają odróżnić awarię techniczną od rezultatu kontroli.

 

## Jak uruchamiać kontrolę regularnie

 

Do jednorazowej kontroli wystarczy uruchomić skrypt ręcznie. W regularnym procesie dodaj go do harmonogramu zadań lub procesu CI: wczytaj aktualną listę, wykonaj żądania, zapisz plik CSV jako artefakt i powiadom zespół, jeśli w kolumnie `issues` pojawią się wartości. Nie wypisuj klucza w logach; przechowuj go jako sekret środowiska wykonawczego.

 

Jeśli często sprawdzasz te same profile, możesz przekazać parametr `cache_timeout` jako liczbę sekund buforowania. Dokumentacja podaje, że buforowanie dla Instagrama jest domyślnie wyłączone; wartość większa od zera włącza je na wskazany okres. Dodaj ten parametr tylko wtedy, gdy można ponownie wykorzystać odpowiedź w wybranym przedziale czasu.

 

Sprawdzaj wyłącznie te dane i scenariusze, do których masz uprawnienia. Traktuj wynik jako migawkę konkretnej odpowiedzi API, zapisuj datę uruchomienia we własnym dzienniku i weryfikuj progi wraz z briefem. Szczegóły ścieżki, dostępnych pól i opcji integracji znajdziesz na stronie [Instagram Scraper API](https://jsonscraper.com/services/ig-scraper-api) oraz w [oficjalnej dokumentacji endpointu](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md).
