# Verificación de perfiles de Instagram antes de una campaña publicitaria: informe de discrepancias con Python

https://jsonscraper.com/es/blog/verificar-perfiles-instagram-campana-python

Author: Michael Johnson

Published: 2026-11-19T11:36:17+00:00

Updated: 2026-11-19T11:36:17+00:00

Obtén información pública de las cuentas del briefing y genera una tabla de excepciones antes de lanzar la campaña

Verificar las cuentas de Instagram antes de lanzar una campaña ayuda a detectar errores en la lista de ubicaciones mientras todavía son fáciles de corregir. Por ejemplo, el briefing puede contener un error tipográfico en un nombre, una cuenta duplicada o un perfil con un número de seguidores inesperado. A continuación se muestra un pequeño script de Python que consulta datos públicos de cada username, compara la respuesta con tus condiciones y guarda las filas verificables en un CSV.

 

## Qué resultado obtendrás

 

Como entrada se proporciona un CSV con una lista de cuentas y valores esperados opcionales. El resultado es una fila independiente por cada username procesado: estado de la solicitud, nombre del perfil, indicador de verificación, número de seguidores, publicaciones y cuentas seguidas, además de una breve lista de las discrepancias encontradas.



![Artículo: Verificación de perfiles de Instagram antes de una campaña publicitaria: informe de discrepancias con Python
Resumen: Si el briefing contiene nombres de cuenta incorrectos, espacios sobrantes o un perfil inadecuado, el equipo podría descubrirlo cuando la campaña ya esté preparada. Te mostramos cómo verificar nombres de usuario de Instagram mediante el endpoint documentado de jsonscraper y exportar las discrepancias observadas a un CSV.
Función de la imagen: portada: idea central
Sección: Qué resultado obtendrás
Tema visual: Foto editorial ](https://jsonscraper.com/assets/uploads/journal/2026/11/84aacded9a89d423a6289b53b549643f.png.hero.webp)

El informe reúne los campos verificados del perfil y las notas para una revisión manual antes de lanzar la campaña.© jsonscraper · generado con IA

 

Este informe resulta útil para un especialista en marketing que compara colaboradores con el briefing y para un desarrollador que integra una verificación interna en una tarea periódica. Se trata de comprobar campos concretos del perfil público en el momento de la solicitud; el equipo conserva la decisión final sobre si cumple los requisitos de la campaña.

 

## Qué campos se pueden verificar

 

La ruta documentada de la API de Instagram `/v1/user/by/username` acepta el parámetro obligatorio `username`. En el formato de respuesta observado, los datos del perfil se encuentran en el objeto `ig`; entre los campos devueltos estaban `username`, `full_name`, `is_private`, `is_verified`, `media_count`, `follower_count`, `following_count` y `biography`. Los campos pueden no estar siempre disponibles, por lo que el script de abajo escribe los valores ausentes como campos vacíos y no los convierte en cero. La [referencia de la API de Instagram](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md) incluye la lista de rutas y nombres de parámetros.

 

La verificación resulta especialmente clara para las condiciones que se pueden expresar explícitamente: el perfil debe ser público, el número de seguidores debe estar dentro del intervalo especificado y el indicador de verificación debe coincidir con los requisitos del briefing. La biografía se puede guardar para revisarla después, pero comparar automáticamente su texto con el posicionamiento de marketing requiere un criterio independiente.

 

## Prepara el archivo de entrada

 

Crea `profiles.csv` en UTF-8. La versión mínima solo contiene username; deja vacíos los campos esperados adicionales si el briefing no establece esa condición:

 

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

 

Los valores de `min_followers` y `max_followers` definen los límites de la verificación. El campo `verified` admite `true` o `false`. Puedes especificar solo las condiciones aplicables a cada perfil.

 

## Solicita los datos y genera el informe

 

Instala `requests` y define la clave en el entorno del proceso, no en el archivo de código fuente. En macOS o Linux, el comando es:



![Artículo: Verificación de perfiles de Instagram antes de una campaña publicitaria: informe de discrepancias con Python
Resumen: Si el briefing contiene nombres de cuenta incorrectos, espacios sobrantes o un perfil inadecuado, el equipo podría descubrirlo cuando la campaña ya esté preparada. Te mostramos cómo verificar nombres de usuario de Instagram mediante el endpoint documentado de jsonscraper y exportar las discrepancias observadas a un CSV.
Función de la imagen: ilustración de apoyo 2: un aspecto específico diferente
Sección: Solicita los datos y genera](https://jsonscraper.com/assets/uploads/journal/2026/11/146a636928d29c035050cacd0aa101b8.png.hero.webp)

El diagrama muestra el recorrido desde el CSV con la lista de cuentas hasta el informe: los campos vacíos se conservan y las coincidencias con las reglas se indican por separado.© jsonscraper · ilustración generada con IA

 

```
python -m pip install requests
export JSONSCRAPER_INSTAGRAM_LICENSE_KEY='tu-clave'
```

 

Guarda el siguiente script como `check_profiles.py`. Usa Python 3.8 o posterior, comprueba el estado externo de la respuesta, lee por separado la carga útil `ig` y crea `profile_check.csv`. La clave se envía como parámetro de consulta `license_key`, tal como indica la documentación del servicio.

 

```
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("Define 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"Filas procesadas: {len(output)}; informe: profile_check.csv")
```

 

## Cómo leer las filas con discrepancias

 

Ejecuta `python check_profiles.py`. En la columna `status`, el valor `ok` significa que el script recibió el objeto de perfil esperado y pudo generar una fila. La columna `issues` contiene únicamente las reglas verificadas: por ejemplo, `private_profile` o `below_min_followers`. Una columna vacía significa que las condiciones registradas no detectaron discrepancias; no confirma la calidad del contenido ni el cumplimiento de otros puntos del contrato.

 

Compara `returned_username` con el username original y remite `biography` y `full_name` a la persona responsable para una revisión cualitativa. El informe también incluye errores de solicitud, estados inesperados de la API y la ausencia del objeto `ig`: esas filas permanecen en la selección y ayudan a distinguir un fallo técnico del resultado de la verificación.

 

## Cómo ejecutar la verificación periódicamente

 

Para una verificación puntual, basta con ejecutar el script manualmente. En un proceso periódico, añádelo al programador de tareas o al flujo de trabajo de CI: carga la lista actualizada, ejecuta las solicitudes, guarda el CSV como artefacto y avisa al equipo si aparecen valores en la columna `issues`. No imprimas la clave en los registros; guárdala como secreto del entorno de ejecución.

 

Si verificas los mismos perfiles con frecuencia, puedes pasar el parámetro `cache_timeout` para indicar el número de segundos de almacenamiento en caché. La documentación indica que, para Instagram, la caché está desactivada de forma predeterminada; un valor superior a cero la activa durante el periodo indicado. Solo tiene sentido añadir este parámetro si es aceptable reutilizar una respuesta dentro del intervalo seleccionado.

 

Verifica únicamente los datos y escenarios para los que tengas autorización. Utiliza el resultado como una instantánea de una respuesta concreta de la API, registra la fecha de ejecución en tu propio historial y revisa los umbrales junto con el briefing. Consulta los detalles de la ruta, los campos disponibles y las opciones de integración en la página de [Instagram Scraper API](https://jsonscraper.com/services/ig-scraper-api) y en la [documentación oficial del endpoint](https://github.com/jsonscraper/instagram-api-python/blob/main/docs/endpoints.md).
