# Validação de perfis do Instagram antes de uma campanha publicitária: relatório de divergências em Python

https://jsonscraper.com/pt/blog/validacao-perfis-instagram-campanha-python

Author: Michael Johnson

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

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

Consulte dados públicos de contas incluídas no briefing e gere uma tabela de exceções antes de lançar a campanha

Verificar contas do Instagram antes de lançar uma campanha ajuda a encontrar erros na lista de posicionamentos enquanto ainda é fácil corrigi-los. Por exemplo, o briefing pode conter um erro de digitação no nome, uma conta duplicada ou um perfil com um número inesperado de seguidores. A seguir, um pequeno script em Python consulta dados públicos de cada nome de usuário, compara a resposta com os critérios definidos e salva as linhas verificadas em um arquivo CSV.

 

## Qual será o resultado

 

A entrada é um CSV com uma lista de contas e valores esperados opcionais. A saída é uma linha separada para cada nome de usuário processado: status da solicitação, nome do perfil, indicação de verificação, números de seguidores, publicações e contas seguidas, além de uma lista resumida das divergências encontradas.



![Artigo: Validação de perfis do Instagram antes de uma campanha publicitária: relatório de divergências em Python
Resumo: Se o briefing incluir nomes de contas incorretos, espaços extras ou um perfil inadequado, a equipe pode só perceber isso depois de preparar a campanha. Veja como verificar nomes de usuário do Instagram usando o endpoint documentado do jsonscraper e exportar as divergências observadas para CSV.
Função da imagem: capa — ideia central
Seção: Qual será o resultado
Tema visual: foto editorial " carregando=](https://jsonscraper.com/assets/uploads/journal/2026/11/84aacded9a89d423a6289b53b549643f.png.hero.webp)

O relatório reúne os campos verificados do perfil e indicações para revisão manual antes do lançamento da campanha.© jsonscraper · criado com IA

 

Esse relatório é útil para profissionais de marketing que conferem os parceiros com o briefing e para desenvolvedores que criam uma verificação interna como tarefa recorrente. Ele controla campos específicos de um perfil público no momento da consulta; a decisão manual sobre a adequação à campanha continua a cargo da equipe.

 

## Quais campos podem ser verificados

 

A rota documentada da API do Instagram `/v1/user/by/username` recebe o parâmetro obrigatório `username`. No formato de resposta observado, os dados do perfil ficam no objeto `ig`; entre os campos retornados estavam `username`, `full_name`, `is_private`, `is_verified`, `media_count`, `follower_count`, `following_count` e `biography`. Os campos podem não estar sempre presentes, por isso o script abaixo registra valores ausentes como vazios, sem convertê-los em zero. A [referência da API do Instagram](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md) lista as rotas e os nomes dos parâmetros.

 

A verificação é especialmente clara para critérios que podem ser definidos explicitamente: o perfil deve ser público, o número de seguidores deve estar dentro de uma faixa definida e a indicação de verificação deve corresponder ao requisito do briefing. A biografia pode ser salva para consulta posterior, mas comparar automaticamente o texto com o posicionamento de marketing exige um critério separado.

 

## Prepare o arquivo de entrada

 

Crie `profiles.csv` em UTF-8. A versão mínima contém apenas o nome de usuário; deixe vazios os campos esperados adicionais quando o briefing não especificar uma restrição:

 

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

 

Os valores de `min_followers` e `max_followers` definem os limites da verificação. O campo `verified` aceita `true` ou `false`. Para cada perfil, você pode indicar apenas os critérios aplicáveis.

 

## Consulte os dados e gere o relatório

 

Instale `requests` e defina a chave no ambiente do processo, e não no arquivo-fonte. No macOS ou Linux, o comando é:



![Artigo: Validação de perfis do Instagram antes de uma campanha publicitária: relatório de divergências em Python
Resumo: Se o briefing incluir nomes de contas incorretos, espaços extras ou um perfil inadequado, a equipe pode só perceber isso depois de preparar a campanha. Veja como verificar nomes de usuário do Instagram usando o endpoint documentado do jsonscraper e exportar as divergências observadas para CSV.
Função da imagem: ilustração de apoio 2 — um aspecto específico diferente
Seção: Consulte os dados e gere o relatório](https://jsonscraper.com/assets/uploads/journal/2026/11/146a636928d29c035050cacd0aa101b8.png.hero.webp)

O diagrama mostra o fluxo do CSV com a lista de contas até o relatório, no qual os campos vazios continuam vazios e as correspondências com as regras são indicadas separadamente.© jsonscraper · ilustração gerada por IA

 

```
python -m pip install requests
export JSONSCRAPER_INSTAGRAM_LICENSE_KEY='sua-chave'
```

 

Salve o script abaixo como `check_profiles.py`. Ele usa Python 3.8 ou superior, verifica o status externo da resposta, lê separadamente o conteúdo `ig` e cria `profile_check.csv`. A chave é enviada como parâmetro de consulta `license_key`, conforme indicado na documentação do serviço.

 

```
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("Defina 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"Linhas processadas: {len(output)}; relatório: profile_check.csv")
```

 

## Como interpretar as linhas com divergências

 

Execute `python check_profiles.py`. Na coluna `status`, o valor `ok` significa que o script recebeu o objeto de perfil esperado e conseguiu criar um registro. A coluna `issues` contém apenas regras verificadas, por exemplo, `private_profile` ou `below_min_followers`. Uma coluna vazia significa que as condições registradas não apontaram divergências; isso não confirma a qualidade do conteúdo nem a conformidade com outros itens do contrato.

 

Compare `returned_username` com o nome de usuário original e encaminhe `biography` e `full_name` a um responsável para uma revisão de conteúdo. O relatório também inclui erros de solicitação, status inesperados da API e ausência do objeto `ig`: essas linhas permanecem na amostra e ajudam a distinguir uma falha técnica do resultado da verificação.

 

## Como executar a verificação regularmente

 

Para uma verificação pontual, basta executar o script manualmente. Em um processo recorrente, adicione-o ao agendador ou ao fluxo de trabalho de CI: carregue a lista atualizada, faça as consultas, salve o CSV como artefato e notifique a equipe se houver valores na coluna `issues`. Não imprima a chave nos logs; armazene-a como segredo no ambiente de execução.

 

Se você verificar os mesmos perfis com frequência, pode enviar `cache_timeout` como o número de segundos de cache. A documentação informa que, por padrão, o cache do Instagram está desativado; um valor superior a zero o ativa pelo período especificado. Só vale a pena adicionar esse parâmetro se for aceitável reutilizar uma resposta durante o intervalo escolhido.

 

Verifique apenas os dados e cenários para os quais você tem autorização. Use o resultado como um retrato de uma resposta específica da API, registre a data da execução em seu próprio log e reveja os limites junto com o briefing. Consulte os detalhes da rota, os campos disponíveis e as opções de integração na página da [Instagram Scraper API](https://jsonscraper.com/services/ig-scraper-api) e na [documentação oficial do endpoint](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md).
