Evaluación en Mundo Abierto

Los mejores scrapers de Instagram para extraer datos de Instagram

actualizado el 23 de jul. de 2026

Instagram sigue siendo una de las plataformas más agresivas para bloquear el scraping automatizado debido a medidas anti-bot avanzadas como la toma de huellas TLS y las verificaciones de reputación de IP.

Tanto si necesitas una API de scraper de alto rendimiento como un script de Python personalizado, esta guía evalúa las mejores herramientas, incluyendo el scraper de Instagram de Apify y el scraper de Instagram de Bright Data.

Proveedor

Para

Bright Data

El tiempo de respuesta más rápido y la mejor eficiencia de costes a escala

Decodo

Más del 90% de tasa de éxito en metadatos de perfil y publicación

Apify

Configuración sin código con "Actores" predefinidos para redes sociales y despliegue rápido

Las mejores herramientas de scraper de Instagram de 2026

Scrapers	Páginas compatibles	Opciones de scraping	Formatos	Tipo de scraper
Bright Data	Comentarios Publicaciones Perfiles Reels	Consulta URL	CSV JSON NDJSON JSON líneas	API especializada
Apify	Comentarios Publicaciones Perfiles Hashtags Reels	Consulta URL	Tabla JSON	API especializada
Decodo	Publicaciones Perfiles Hashtags Reels	Consulta	Tabla JSON	API especializada
Nimble	Sin plantillas predefinidas para IG	Consulta	JHTML JSON	Propósito general

Los proveedores con enlaces son patrocinadores de AIMultiple.

API especializada: API de scraper específica para Instagram, diseñada para recopilar datos exclusivamente de Instagram. Por ejemplo, Bright Data ofrece plantillas adaptadas a puntos de datos específicos de Instagram, como "instagram-comments-collect by URL".
Propósito general: Ofrece un scraper versátil que no está especializado para Instagram, pero que se puede modificar para manejar tareas de scraping web de Instagram.
Tipos de páginas compatibles: Páginas donde la herramienta de scraping de Instagram entrega datos en un formato estructurado.

Resultados del benchmark de scrapers de Instagram

Compara el tiempo de respuesta mediano de los proveedores y el número promedio de campos que devolvieron en nuestro benchmark:

Estabilidad de las tasas de éxito de los scrapers de Instagram a lo largo del tiempo

Eficiencia de costes del scraper de Instagram por volumen mensual

Las opciones de precios mensuales para estos proveedores se enumeran a continuación.

Características de los mejores scrapers de Instagram

Bright Data

Bright Data ofrece dos soluciones para Instagram: una API de scraper en tiempo real para perfiles, publicaciones, comentarios y reels, y conjuntos de datos pre-recopilados para análisis histórico a gran escala. Los tutoriales de Python en esta página utilizan la API de conjuntos de datos.

Nuestra API de scraper ofrece los tiempos de respuesta más rápidos y la mejor eficiencia de costes a escala, con una tasa de éxito superior al 90% para metadatos de perfil y publicación en nuestros benchmarks. Solo se te cobra por los resultados exitosos; las solicitudes fallidas no se facturan. La API incluye cinco endpoints específicos de Instagram: perfiles, publicaciones, reels, comentarios y conjuntos de datos.

Decodo

Los destinos de Instagram de Decodo (instagram_graphql_profile, instagram_graphql_user_posts, instagram_graphql_post) devuelven JSON analizado a través de REST, disponible en planes avanzados; los planes básicos devuelven datos de página sin procesar sin análisis específico del destino.

La herramienta logró una alta tasa de éxito en nuestro benchmark, similar a Bright Data, con más del 90% de precisión en metadatos de perfil y publicación. Sin embargo, su cobertura de endpoints es más limitada que la de Bright Data o Apify, y actualmente no ofrece soporte dedicado para reels o destinos de hashtags.

Apify

El Actor apify/instagram-scraper de Apify es una de las ocho herramientas enfocadas en Instagram disponibles en la tienda. Admite el scraping de publicaciones, reels, comentarios, menciones, perfiles y hashtags, así como lugares, y permite el descubrimiento basado en palabras clave además de la entrada de URL.

La consola sin código permite a los usuarios pegar una URL o palabra clave y ejecutar el scraper sin integración de API. Además del scraping directo de URL, ofrece descubrimiento basado en palabras clave para hashtags, lugares o usuarios. Las respuestas a comentarios y el orden de comentarios más recientes primero están disponibles en planes de pago, mientras que el plan gratuito está limitado a aproximadamente 15 comentarios por publicación.

Nimble

No todos los proveedores en esta comparación funcionan como scrapers de Instagram de la misma manera que los tres mencionados anteriormente. Por ejemplo, Nimble no ofrece un endpoint o esquema específico para Instagram. En su lugar, es una API web general que procesa cualquier URL a través de un analizador impulsado por IA y devuelve JSON estructurado. La salida depende de lo que el modelo extraiga de la página en el momento de la solicitud, en lugar de un conjunto fijo de campos.

Nimble no publica precios por registro para Instagram; el acceso se basa en cotización. Es una opción adecuada si necesitas una única API para múltiples sitios y puedes adaptarte a cambios en el esquema.

API de scraper de Instagram vs código Python

El scraping básico con Python no funciona en Instagram debido a los sólidos sistemas anti-bot, por lo que dependemos de APIs de scraper que manejan proxies, simulación de navegador y límites de tasa.
Creamos tres scrapers en Python: perfiles, publicaciones y comentarios, cada uno utilizando trabajos de API basados en instantáneas y salidas CSV limpias.
Usamos la búsqueda de Google para descubrir URLs de publicaciones de Instagram de manera confiable dentro de filtros de palabras clave y fechas.
Nuestro sistema de sondeo maneja estados de instantáneas, descargas alternativas, análisis de líneas JSON y tiempos de espera de 15 minutos.

Crear un scraper de seguidores de Instagram con Python

Paso 1: Configuración

1import time
2import json
3import pandas as pd
4import requests
5import urllib3
6
7urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
8
9API_TOKEN = "your_api_token_here"
10INSTAGRAM_PROFILES_DATASET_ID = "dataset_id_for_instagram_profiles_from_brightdata"
11
12profile_urls = [
13    "https://www.instagram.com/langchain.ai/",
14]

Este paso:

Importa las bibliotecas de Python para solicitudes HTTP, JSON y pandas.
Establece tu token de API y el ID del conjunto de datos de perfiles de Instagram.
Define profile_urls, la lista de cuentas de Instagram que deseas extraer (aquí es langchain.ai, pero puedes agregar tantas como quieras).

Paso 2: Envío de URLs de perfil al scraper web

1trigger_url = "api_trigger_endpoint_url"
2headers = {
3    "Authorization": f"Bearer {API_TOKEN}",
4    "Content-Type": "application/json",
5}
6params = {
7    "dataset_id": INSTAGRAM_PROFILES_DATASET_ID,
8    "include_errors": "true",
9}
10
11data = [{"url": u} for u in profile_urls]
12
13try:
14    response = requests.post(trigger_url, headers=headers, params=params, json=data)
15
16    if response.status_code == 200:
17        result = response.json()
18        snapshot_id = result.get("snapshot_id")
19    else:
20        exit()
21
22except Exception as e:
23    exit()

Aquí inicias el trabajo de scraping de perfiles:

Cada URL de perfil se envuelve como un objeto en los datos y se envía al conjunto de datos de perfiles.
La API responde con un snapshot_id que representa este trabajo; lo usarás en el siguiente paso para obtener los datos del perfil extraídos.

Paso 3: Sondeo de la API hasta que los datos del perfil estén listos

1snapshot_url = f"api_snapshot_endpoint_url/{snapshot_id}"
2headers = {"Authorization": f"Bearer {API_TOKEN}"}
3
4start_time = time.time()
5max_wait_seconds = 15 * 60
6
7items = []
8while True:
9    elapsed = time.time() - start_time
10    if elapsed > max_wait_seconds:
11        exit()
12
13    try:
14        response = requests.get(snapshot_url, headers=headers)
15
16        if response.status_code not in [200, 202]:
17            time.sleep(10)
18            continue
19
20        if response.status_code == 202:
21            time.sleep(10)
22            continue
23
24        try:
25            data = response.json()
26            status = data.get("status")
27
28            if status in ["ready", "done", "complete"]:
29                download_url = data.get("download_url")
30                if download_url:
31                    download_response = requests.get(download_url)
32
33                    for line in download_response.text.strip().split('\n'):
34                        if line.strip():
35                            try:
36                                items.append(json.loads(line))
37                            except json.JSONDecodeError:
38                                pass
39
40                if items:
41                    break
42
43            items = data.get("items", [])
44            if items:
45                break
46
47            download_response = requests.get(
48                f"api_download_endpoint/{snapshot_id}/download",
49                headers=headers
50            )
51
52            for line in download_response.text.strip().split('\n'):
53                if line.strip():
54                    try:
55                        items.append(json.loads(line))
56                    except:
57                        pass
58
59            if items:
60                break
61            else:
62                exit()
63
64            elif status == "failed":
65                exit()
66
67        except json.JSONDecodeError:
68            for line in response.text.strip().split('\n'):
69                if line.strip():
70                    try:
71                        items.append(json.loads(line))
72                    except:
73                        pass
74
75            if items:
76                break
77
78        time.sleep(10)
79
80    except Exception as e:
81        time.sleep(10)
82
83if not items:
84    exit()

Este bucle:

Verifica el estado de la instantánea cada 10 segundos, hasta un tiempo de espera de 15 minutos.
Maneja tanto el formato "listo con download_url" como el de "elementos incrustados en la respuesta", además de un endpoint de descarga alternativo.
Recopila todos los registros de perfil devueltos en la lista de elementos antes de continuar.

Paso 4: Procesamiento y guardado de datos de perfil de Instagram

1csv_data = []
2
3for item in items:
4    try:
5        followers = int(item.get('followers', 0))
6    except (ValueError, TypeError):
7        followers = 0
8
9    try:
10        posts_count = int(item.get('posts_count', 0))
11    except (ValueError, TypeError):
12        posts_count = 0
13
14    try:
15        avg_engagement = float(item.get('avg_engagement', 0.0))
16    except (ValueError, TypeError):
17        avg_engagement = 0.0
18
19    csv_data.append({
20        'account': item.get('account', 'N/A'),
21        'fbid': item.get('fbid', 'N/A'),
22        'id': item.get('id', 'N/A'),
23        'followers': followers,
24        'posts_count': posts_count,
25        'is_business_account': item.get('is_business_account', False),
26        'is_professional_account': item.get('is_professional_account', False),
27        'is_verified': item.get('is_verified', False),
28        'avg_engagement': avg_engagement,
29        'external_url': item.get('external_url', 'N/A'),
30        'biography': item.get('biography', 'N/A'),
31        'full_name': item.get('full_name', 'N/A')
32    })
33
34df = pd.DataFrame(csv_data)
35output_filename = 'instagram_profiles_data.csv'
36df.to_csv(output_filename, index=False, encoding='utf-8-sig')

Finalmente, conviertes los registros sin procesar de la API en un conjunto de datos limpio:

Analiza de forma segura campos numéricos como seguidores, posts_count y avg_engagement.
Conserva atributos de perfil útiles: IDs de cuenta, indicadores de negocio/profesional, estado de verificación, biografía, nombre completo y URL externa.
Almacena todo en un DataFrame de pandas y lo escribe en instagram_profiles_data.csv para su posterior análisis o informes.

Deja que nuestro equipo automatice uno de tus procesos de negocio con agentes de IA, sin coste alguno.

Automatizar un proceso

Scraper de publicaciones de Instagram (tutorial de Python)

Paso 1: Configuración

En este ejemplo, usaremos la API de conjuntos de datos de Instagram más proxies para recopilar publicaciones de Instagram que coincidan con una palabra clave dentro de un rango de fechas.

1import urllib.parse
2import re
3import time
4import json
5import pandas as pd
6import requests
7import urllib3
8from datetime import datetime
9
10urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
11
12API_TOKEN = "your_api_token_here"
13INSTAGRAM_DATASET_ID = "dataset_id_for_instagram_from_brightdata"
14
15proxy = {
16    "http": 'http://your_proxy_url',
17    "https": 'http://your_proxy_url'
18}
19
20KEYWORD = "Agentic AI Frameworks"
21NUM_POSTS = 5
22DATE_START = "11.05.2025"
23DATE_END = "11.10.2025"

Este bloque:

Importa las bibliotecas de Python para análisis de URL, solicitudes HTTP, manejo de JSON y análisis de datos con pandas.
Establece tu token de API y el ID del conjunto de datos de Instagram.
Configura el proxy para el scraping de Instagram.
Define los parámetros de búsqueda: KEYWORD, el número de publicaciones a obtener (NUM_POSTS) y la ventana de fechas (DATE_START → DATE_END).

Paso 2: Encontrar publicaciones de Instagram mediante la búsqueda de Google

Usamos la búsqueda de Google para encontrar publicaciones de Instagram relevantes que coincidan con nuestros criterios dentro de un rango de fechas específico.

1all_urls = []
2start = 0
3max_pages = 5
4
5while len(all_urls) < NUM_POSTS and start < max_pages * 10:
6    query = f'site:instagram.com/p/ "{KEYWORD}" after:2025-05-11 before:2025-10-11'
7    encoded_query = urllib.parse.quote(query)
8    url = f"https://google.com/search?q={encoded_query}&start={start}&gl=us&hl=en&num=20"
9
10    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
11
12    try:
13        response = requests.get(url, headers=headers, proxies=proxy, verify=False, timeout=30)
14        html = response.text
15    except Exception as e:
16        break
17
18    patterns = [
19        r'https://www\.instagram\.com/p/[A-Za-z0-9_-]+/?',
20        r'https://instagram\.com/p/[A-Za-z0-9_-]+/?',
21    ]
22
23    found_urls = []
24    seen_urls = set()
25
26    for pattern in patterns:
27        matches = re.findall(pattern, html)
28        for match in matches:
29            clean_url = match.split('?')[0].split('#')[0].rstrip('/')
30
31            if 'www.instagram.com' not in clean_url:
32                clean_url = clean_url.replace('instagram.com', 'www.instagram.com')
33
34            if clean_url not in seen_urls:
35                seen_urls.add(clean_url)
36                found_urls.append(clean_url)
37
38    if not found_urls:
39        break
40
41    for found_url in found_urls:
42        if found_url not in all_urls:
43            all_urls.append(found_url)
44            if len(all_urls) >= NUM_POSTS:
45                break
46
47    if len(all_urls) >= NUM_POSTS:
48        break
49
50    start += 10
51    time.sleep(2)
52
53instagram_urls = all_urls[:NUM_POSTS]
54
55if not instagram_urls:
56    exit()

Este paso utiliza la búsqueda de Google para encontrar publicaciones. El script:

Construye una consulta como site:instagram.com/p/ “{KEYWORD}” after: DATE_START before: DATE_END y pagina a través de los resultados de Google.
Utiliza patrones regex para extraer las URLs de las publicaciones de Instagram del HTML, las normaliza (www.instagram.com vs instagram.com) y elimina duplicados.
Se detiene cuando ha recopilado NUM_POSTS URLs únicas o cuando alcanza el número máximo de páginas de resultados de Google.

Paso 3: Envío de URLs de publicaciones de Instagram a la API para scraping

1trigger_url = "api_trigger_endpoint_url"
2headers = {
3    "Authorization": f"Bearer {API_TOKEN}",
4    "Content-Type": "application/json",
5}
6params = {
7    "dataset_id": INSTAGRAM_DATASET_ID,
8    "include_errors": "true",
9}
10
11data = [{"url": u} for u in instagram_urls]
12
13try:
14    response = requests.post(trigger_url, headers=headers, params=params, json=data)
15
16    if response.status_code == 200:
17        result = response.json()
18        snapshot_id = result.get("snapshot_id")
19    else:
20        exit()
21
22except Exception as e:
23    exit()

Este paso inicia el trabajo de scraping real:

Envía todas las URLs de Instagram recopiladas al conjunto de datos de Instagram en una única solicitud por lotes.
La API devuelve un snapshot_id que identifica este trabajo de scraping y se utiliza en el siguiente paso para obtener los resultados una vez que se complete el procesamiento.

Paso 3: Sondeo de resultados y guardado de datos

1snapshot_url = f"api_snapshot_endpoint_url/{snapshot_id}"
2headers = {"Authorization": f"Bearer {API_TOKEN}"}
3
4start_time = time.time()
5max_wait_seconds = 15 * 60
6
7items = []
8while True:
9    elapsed = time.time() - start_time
10    if elapsed > max_wait_seconds:
11        exit()
12
13    try:
14        response = requests.get(snapshot_url, headers=headers)
15
16        if response.status_code not in [200, 202]:
17            time.sleep(10)
18            continue
19
20        if response.status_code == 202:
21            time.sleep(10)
22            continue
23
24        try:
25            data = response.json()
26            status = data.get("status")
27
28            if status in ["ready", "done", "complete"]:
29                download_url = data.get("download_url")
30                if download_url:
31                    download_response = requests.get(download_url)
32
33                    for line in download_response.text.strip().split('\n'):
34                        if line.strip():
35                            try:
36                                items.append(json.loads(line))
37                            except json.JSONDecodeError:
38                                pass
39
40                if items:
41                    break
42
43            items = data.get("items", [])
44            if items:
45                break
46
47            download_response = requests.get(
48                f"api_download_endpoint/{snapshot_id}/download",
49                headers=headers
50            )
51
52            for line in download_response.text.strip().split('\n'):
53                if line.strip():
54                    try:
55                        items.append(json.loads(line))
56                    except:
57                        pass
58
59            if items:
60                break
61            else:
62                exit()
63
64            elif status == "failed":
65                exit()
66
67        except json.JSONDecodeError:
68            for line in response.text.strip().split('\n'):
69                if line.strip():
70                    try:
71                        items.append(json.loads(line))
72                    except:
73                        pass
74
75            if items:
76                break
77
78        time.sleep(10)
79
80    except Exception as e:
81        time.sleep(10)
82
83if not items:
84    exit()
85
86csv_data = []
87
88for item in items:
89    try:
90        likes = int(item.get('likes', 0))
91    except (ValueError, TypeError):
92        likes = 0
93
94    try:
95        num_comments = int(item.get('num_comments', 0))
96    except (ValueError, TypeError):
97        num_comments = 0
98
99    hashtags = item.get('hashtags', [])
100    hashtags_str = ', '.join(hashtags) if isinstance(hashtags, list) else str(hashtags)
101
102    photos = item.get('photos', [])
103    photos_str = ', '.join(photos) if isinstance(photos, list) else str(photos)
104
105    videos = item.get('videos', [])
106    videos_str = ', '.join(videos) if isinstance(videos, list) else str(videos)
107
108    csv_data.append({
109        'user_posted': item.get('user_posted', 'N/A'),
110        'description': item.get('description', 'N/A'),
111        'date_posted': item.get('date_posted', 'N/A'),
112        'likes': likes,
113        'num_comments': num_comments,
114        'hashtags': hashtags_str,
115        'location': item.get('location', 'N/A'),
116        'photos': photos_str,
117        'videos': videos_str
118    })
119
120df = pd.DataFrame(csv_data)
121output_filename = f'instagram_{KEYWORD.replace(" ", "_").lower()}_posts.csv'
122df.to_csv(output_filename, index=False, encoding='utf-8-sig')

Scraper de comentarios de Instagram (Python)

Paso 1: Configuración

1import urllib.parse
2import re
3import time
4import json
5import pandas as pd
6import requests
7import urllib3
8from datetime import datetime
9
10urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
11
12API_TOKEN = "your_api_token_here"
13INSTAGRAM_COMMENTS_DATASET_ID = "dataset_id_for_instagram_comments_from_brightdata"
14
15proxy = {
16    "http": 'http://your_proxy_url',
17    "https": 'http://your_proxy_url'
18}
19
20KEYWORD = "Agentic AI Frameworks"
21NUM_POSTS = 5
22DATE_START = "11.05.2025"
23DATE_END = "11.10.2025"

Este paso:

Importa bibliotecas para manejo de URL, expresiones regulares, solicitudes HTTP y pandas.
Establece tu ID de conjunto de datos de comentarios y API_TOKEN.
Configura el proxy a utilizar y define los parámetros de búsqueda: palabra clave, el número de publicaciones de las que extraer comentarios y la ventana de fechas.

Paso 2: Encontrar publicaciones de Instagram mediante la búsqueda de Google

1all_urls = []
2start = 0
3max_pages = 5
4
5while len(all_urls) < NUM_POSTS and start < max_pages * 10:
6    query = f'site:instagram.com/p/ "{KEYWORD}" after:2025-05-11 before:2025-10-11'
7    encoded_query = urllib.parse.quote(query)
8    url = f"https://google.com/search?q={encoded_query}&start={start}&gl=us&hl=en&num=20"
9
10    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
11
12    try:
13        response = requests.get(url, headers=headers, proxies=proxy, verify=False, timeout=30)
14        html = response.text
15    except Exception as e:
16        break
17
18    patterns = [
19        r'https://www\.instagram\.com/p/[A-Za-z0-9_-]+/?',
20        r'https://instagram\.com/p/[A-Za-z0-9_-]+/?',
21    ]
22
23    found_urls = []
24    seen_urls = set()
25
26    for pattern in patterns:
27        matches = re.findall(pattern, html)
28        for match in matches:
29            clean_url = match.split('?')[0].split('#')[0].rstrip('/')
30
31            if 'www.instagram.com' not in clean_url:
32                clean_url = clean_url.replace('instagram.com', 'www.instagram.com')
33
34            if clean_url not in seen_urls:
35                seen_urls.add(clean_url)
36                found_urls.append(clean_url)
37
38    if not found_urls:
39        break
40
41    for found_url in found_urls:
42        if found_url not in all_urls:
43            all_urls.append(found_url)
44            if len(all_urls) >= NUM_POSTS:
45                break
46
47    if len(all_urls) >= NUM_POSTS:
48        break
49
50    start += 10

Aquí:

Utilizas la búsqueda de Google con la consulta site:instagram.com/p/ y tus filtros de palabra clave y fecha para encontrar publicaciones relevantes.
Extraes y normalizas las URLs de las publicaciones de Instagram con regex, eliminas duplicados y te detienes una vez que tienes NUM_POSTS publicaciones.
Almacenas la lista final en instagram_urls, que alimentará el scraper de comentarios.

Paso 3: Envío de URLs de publicaciones a la API del scraper de comentarios

1trigger_url = "api_trigger_endpoint_url"
2headers = {
3    "Authorization": f"Bearer {API_TOKEN}",
4    "Content-Type": "application/json",
5}
6params = {
7    "dataset_id": INSTAGRAM_COMMENTS_DATASET_ID,
8    "include_errors": "true",
9}
10
11data = [{"url": u} for u in instagram_urls]
12
13try:
14    response = requests.post(trigger_url, headers=headers, params=params, json=data)
15
16    if response.status_code == 200:
17        result = response.json()
18        snapshot_id = result.get("snapshot_id")
19    else:
20        exit()
21
22except Exception as e:
23    exit()

Este paso:

Envía todas las URLs de Instagram al conjunto de datos de comentarios de Instagram en un solo lote.
Cada URL se envuelve como {“url”: …} para que la API sepa de qué publicación extraer los comentarios.
La API devuelve un snapshot_id que identifica este trabajo de scraping de comentarios.

Paso 4: Sondeo de resultados y guardado de datos de comentarios

Verificamos continuamente si el scraping se ha completado, luego procesamos y guardamos los datos de los comentarios.

1snapshot_url = f"api_snapshot_endpoint_url/{snapshot_id}"
2headers = {"Authorization": f"Bearer {API_TOKEN}"}
3
4start_time = time.time()
5max_wait_seconds = 15 * 60
6
7items = []
8while True:
9    elapsed = time.time() - start_time
10    if elapsed > max_wait_seconds:
11        exit()
12
13    try:
14        response = requests.get(snapshot_url, headers=headers)
15
16        if response.status_code not in [200, 202]:
17            time.sleep(10)
18            continue
19
20        if response.status_code == 202:
21            time.sleep(10)
22            continue
23
24        try:
25            data = response.json()
26
27            status = data.get("status")
28
29            if status in ["ready", "done", "complete"]:
30                download_url = data.get("download_url")
31                if download_url:
32                    download_response = requests.get(download_url)
33
34                    for line in download_response.text.strip().split('\n'):
35                        if line.strip():
36                            try:
37                                items.append(json.loads(line))
38                            except json.JSONDecodeError:
39                                pass
40
41                    if items:
42                        break
43
44                items = data.get("items", [])
45                if items:
46                    break
47
48                download_response = requests.get(
49                    f"api_download_endpoint/{snapshot_id}/download",
50                    headers=headers
51                )
52
53                for line in download_response.text.strip().split('\n'):
54                    if line.strip():
55                        try:
56                            items.append(json.loads(line))
57                        except:
58                            pass
59
60                if items:
61                    break
62                else:
63                    exit()
64
65            elif status == "failed":
66                exit()
67
68        except json.JSONDecodeError:
69            for line in response.text.strip().split('\n'):
70                if line.strip():
71                    try:
72                        items.append(json.loads(line))
73                    except:
74                        pass
75
76            if items:
77                break
78
79        time.sleep(10)
80
81    except Exception as e:
82        time.sleep(10)
83
84if not items:
85    exit()
86
87csv_data = []
88
89for item in items:
90    try:
91        likes_number = int(item.get('likes_number', 0))
92    except (ValueError, TypeError):
93        likes_number = 0
94
95    try:
96        replies_number = int(item.get('replies_number', 0))
97    except (ValueError, TypeError):
98        replies_number = 0
99
100    hashtag_comment = item.get('hashtag_comment', [])
101    hashtag_comment_str = ', '.join(hashtag_comment) if isinstance(hashtag_comment, list) else str(hashtag_comment)
102
103    tagged_users = item.get('tagged_users_in_comment', [])
104    tagged_users_str = ', '.join(tagged_users) if isinstance(tagged_users, list) else str(tagged_users)
105
106    csv_data.append({
107        'url': item.get('url', 'N/A'),
108        'comment_user': item.get('comment_user', 'N/A'),
109        'comment_user_url': item.get('comment_user_url', 'N/A'),
110        'comment_date': item.get('comment_date', 'N/A'),
111        'comment': item.get('comment', 'N/A'),
112        'likes_number': likes_number,
113        'replies_number': replies_number,
114        'hashtag_comment': hashtag_comment_str,
115        'tagged_users_in_comment': tagged_users_str
116    })
117
118df = pd.DataFrame(csv_data)
119output_filename = f'instagram_{KEYWORD.replace(" ", "_").lower()}_comments.csv'
120df.to_csv(output_filename, index=False, encoding='utf-8-sig')

Esta sección sondea la API cada 10 segundos hasta que se completa el scraping. Una vez listo, recupera todos los datos de comentarios, extrayendo información clave como el nombre de usuario del comentarista, el texto del comentario, los "me gusta", las respuestas, los hashtags utilizados y los usuarios etiquetados. Los datos se estructuran en un DataFrame de pandas y se guardan como un archivo CSV.

Descubre más de nuestros análisis comparativos e insights basados en datos en la Búsqueda de Google.

Añadir como fuente preferida

Cómo Instagram detecta los scrapers (por qué los scripts básicos de Python fallan)

Los scripts simples de Python que utilizan requests fallan de inmediato porque carecen del comportamiento real del navegador y dependen de una única IP que se bloquea en cuestión de minutos. La plataforma puede detectar los scrapers web de Instagram al instante a través de múltiples capas de defensas:

Sin ejecución de JavaScript: Instagram carga la página de forma dinámica, y los scripts de Python no pueden ejecutar JavaScript, por lo que las páginas aparecen vacías. Esto revela instantáneamente un comportamiento no humano.
Limitación de tasa: Los usuarios humanos no realizan 50 solicitudes por segundo. Los scrapers básicos reintentan con tiempos predecibles, e Instagram bloquea esto de inmediato.
Reputación de IP: Instagram mantiene puntuaciones de confianza de IP en tiempo real, IPs de centros de datos y duplicación de IP. No uses proxies gratuitos; estos se bloquean después de unas pocas solicitudes.

Utilizamos una API de scraper web que maneja la simulación del navegador, la rotación de IP, JavaScript, los límites de tasa y la resolución de captchas.

Proxies, límites de tasa y ejecución de tu scraper de Instagram a escala

Instagram prohibirá cualquier script que reutilice la misma IP repetidamente. Para hacer scraping de Instagram a escala, debes usar proxies residenciales rotativos, respetar los límites de tasa, introducir retrasos y evitar las solicitudes directas a Instagram. Así es como utilizamos proxies al extraer datos de Instagram:

1proxy = {
2    "http": 'http://your_proxy_url',
3    "https": 'http://your_proxy_url'
4}

A escala, Instagram realiza verificaciones de velocidad (demasiadas solicitudes demasiado rápido) y verificaciones de concurrencia (demasiadas solicitudes a la vez). Nuestro tutorial evita esto al:

dormir entre las páginas de búsqueda de Google (time.sleep(2))
sondear las APIs cada 10 segundos,
nunca acceder directamente a Instagram.

Scrapers de Instagram utilizados en el benchmark

Nuestro benchmark probó las soluciones de API de scraper dedicadas para Instagram que se enumeran a continuación. Para obtener más información, consulta la metodología del benchmark para APIs de scraping web.

Tipo de página	Apify	Bright Data	Oxylabs	Smartproxy	Zyte
Publicación de Instagram	apify/instagram-scraper	Instagram – Posts-collect by URL	❌	Social Media Scraping API – instagram_grap hql_post	❌
Perfil de Instagram	apify/instagram-profile-scraper	Instagram – Profiles – collect by URL	❌	Social Media Scraping API – instagram_grap hql_post	❌

Consulta qué grandes empresas de infraestructura web ofrecen scrapers específicos para páginas de Instagram:

Proveedor	Publicación de Instagram	Perfil de Instagram
Bright Data	✅	✅
Apify	✅	✅
Decodo	✅	✅
NetNut	❌	❌
Oxylabs	❌	❌
Zyte	❌	❌

¿Qué es el scraping de Instagram?

El scraping de Instagram se refiere al proceso de utilizar software automatizado, como bots o scripts, para recopilar datos públicos de las páginas de Instagram, incluyendo publicaciones, hashtags y comentarios.

En lugar de que un humano visite manualmente un perfil para copiar la biografía y pegarla en Excel, un script automatiza este proceso miles de veces, organizando los datos en un formato estructurado como CSV o JSON para su análisis.

Preguntas frecuentes

El scraping de datos públicos de Instagram está permitido siempre que respetes los términos de la plataforma y las leyes aplicables para el análisis de la competencia, el monitoreo de marca y el análisis de sentimiento. Sin embargo, siempre debes:

* Cumplir las Condiciones de Uso de Instagram
* Evitar recopilar datos personales que no estén destinados a ser públicos
* Usar una herramienta de scraping de Instagram que cumpla con las regulaciones regionales

Puedes extraer publicaciones, perfiles públicos y datos de comentarios. Esto incluye nombres de usuario de Instagram, recuento de seguidores, número de publicaciones, métricas de participación, detalles de publicaciones (me gusta, hashtags, medios) y texto de comentarios con metadatos básicos.

Sí. Instagram bloquea el scraping directo, por lo que nuestro tutorial evita acceder directamente a Instagram y utiliza una API de scraping que gestiona el bloqueo, los límites de tasa y la toma de huellas por nosotros.

Los endpoints de la API de Instagram, como la API Graph de Instagram, no proporcionan los datos públicos de perfil, publicación y comentarios que extraemos en este tutorial. Funciona para tu propia cuenta de negocio y requiere permisos y revisión de la aplicación, por lo que recurrimos a APIs de scraper en su lugar.

Cita este benchmark

Elige el formato que se ajuste al lugar donde vas a publicar. Pegar la versión con enlace en tu CMS conserva el enlace de retroceso.

Gulbahar Karatas (2026) - "Los mejores scrapers de Instagram para extraer datos de Instagram". Publicado en línea en AIMultiple.com. Recuperado el 23 de Julio de 2026, de: https://aimultiple.com/instagram-scraping [Recurso en línea]

Karatas, G. (2026, 23 de Julio). Los mejores scrapers de Instagram para extraer datos de Instagram. AIMultiple. https://aimultiple.com/instagram-scraping

@misc{karatas2026,
  author = {Karatas, Gulbahar},
  title  = {{Los mejores scrapers de Instagram para extraer datos de Instagram}},
  year   = {2026},
  month  = jul,
  howpublished    = {\url{https://aimultiple.com/instagram-scraping}},
  note   = {AIMultiple. Recuperado el 23 de Julio de 2026}
}

Gulbahar Karatas

Analista de la Industria

Gülbahar es una analista de la industria de AIMultiple enfocada en la recopilación de datos web, las aplicaciones de datos web y la seguridad de aplicaciones.

Ver perfil completo