Is it legal to scrape Instagram?

Scraping publicly available Instagram data is allowed as long as you respect the platform’s terms and applicable laws for competitor analysis, brand monitoring, and sentiment analysis. However, always:* Follow Instagram’s Terms of Use* Avoid collecting personal data that is not intended to be public* Usan e Instagram scraping tool that complies with regional regulations

What Instagram data can you scrape?

You can scrape posts, public profiles, and comment data. This includes Instagram usernames, follower counts, posts count, engagement metrics, post details (likes, hashtags, media), and comment text with basic metadata.

Does Instagram block scraping?

Yes. Instagram blocks direct scraping, which is why our tutorial avoids hitting Instagram directly and uses a scraping API that handles blocking, rate limits, and fingerprinting for us.

Why not use the official Instagram API?

Instagram's API endpoints, like the Instagram Graph API, don’t provide the public profile, post, and comment data we scrape in this tutorial. It works for your own business account and requires permissions and app review, so we rely on scraper APIs instead.

Citar Este Benchmark

Mejores scrapers de Instagram para extraer datos de Instagram

Gulbahar Karatas

actualizado el 1 de jul. de 2026

Vea nuestra normas éticas

Citar Este Benchmark

Instagram sigue siendo una de las plataformas más agresivas para bloquear el scraping automatizado debido a medidas antibot avanzadas como el fingerprinting TLS y las comprobaciones de reputación de IP.

Ya sea que necesites un scraper de alto rendimiento API o un script de Python personalizado, esta guía evalúa las mejores herramientas, incluyendo Apify Instagram Scraper y Bright Data Instagram Scraper.

Proveedor

Para

Bright Data

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

Decodo

90%+ tasa de éxito en metadatos de perfiles y publicaciones

Apify

Configuración sin código con "Actores" de redes sociales prediseñados para un despliegue rápido

Las mejores herramientas de scraper de Instagram de 2026

Scrapers	Páginas soportadas	Opciones de scrapeo	Formatos	Tipo de scraper
Bright Data	Comentarios Publicaciones Perfiles Reels	Consulta URL	CSV JSON NDJSON JSON lines	Especializada API ¹
Apify	Comentarios Publicaciones Perfiles Hashtags Reels	Consulta URL	Table JSON	Especializada API ²
Decodo	Publicaciones Perfiles Hashtags Reels	Consulta	Table JSON	Especializada API ³
Nimble	Sin plantillas predefinidas para IG	Consulta	JHTML JSON	Uso general

Los proveedores con enlaces son patrocinadores de AIMultiple.

API especializada: API de scraper específica de 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".
Uso general: Ofrece un scraper versátil que no está especializado para Instagram pero que puede modificarse para realizar tareas de scraping web de Instagram.
Tipos de páginas soportadas: Páginas donde la herramienta de scraping de Instagram entrega datos en un formato estructurado.

Resultados del benchmark de scrapers de Instagram

Compare el tiempo de respuesta medio 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

A continuación se enumeran las opciones de precios mensuales de estos proveedores.

Características de los principales 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 Dataset.

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% en metadatos de perfil y publicación en nuestros benchmarks. Solo se te cobra por resultados exitosos; las solicitudes fallidas no se cobran. La API incluye cinco endpoints específicos de Instagram: perfiles, publicaciones, reels, comentarios y datasets.

Decodo

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

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 objetivos de reels o hashtags.

Apify

El Actor apify/instagram-scraper de Apify es una de las ocho herramientas centradas en Instagram disponibles en la tienda. Soporta 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 free está limitado a aproximadamente 15 comentarios por publicación.

Nimble

No todos los proveedores de 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 de Instagram. En su lugar, es una API web general que procesa cualquier URL a través de un analizador basado en IA y devuelve JSON estructurado. El resultado depende de lo que el modelo extrae de la página en el momento de la solicitud, en lugar de un conjunto fijo de campos.

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

API de scraper de Instagram vs código Python

El scraping básico con Python no funciona en Instagram debido a los fuertes sistemas antibot, por lo que dependemos de APIs de scraper que gestionan proxies, la simulación del navegador y los límites de velocidad.
Hemos creado tres scrapers en Python: perfiles, publicaciones y comentarios, cada uno utilizando trabajos de API basados en instantáneas y salidas CSV limpias.
Utilizó la búsqueda de Google para descubrir URL de publicaciones de Instagram dentro de filtros de palabras clave y fechas de manera fiable.
Nuestro sistema de sondeo maneja estados de instantáneas, descargas de respaldo, 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 e instalació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 librerías de Python para solicitudes HTTP, JSON y pandas.
Configura tu token de API y el ID del dataset de perfiles de Instagram.
Define profile_urls, la lista de cuentas de Instagram que deseas scrapear (aquí es langchain.ai, pero puedes añadir tantas como quieras).

Paso 2: Envío de URL de perfiles 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 data y se envía al dataset de perfiles.
La API responde con un snapshot_id que representa este trabajo; lo usarás en el siguiente paso para obtener los datos de perfil scrapeados.

Paso 3: Consultar 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 los formatos "listo con download_url" como "elementos incrustados en la respuesta", además de un endpoint de descarga de respaldo.
Recopila todos los registros de perfil devueltos en la lista items 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 dataset limpio:

Analiza de forma segura campos numéricos como followers, 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 generación de informes.

Scraper de publicaciones de Instagram (tutorial de Python)

Paso 1: Configuración e instalación

En este ejemplo, usaremos la API de dataset 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 librerías de Python para el análisis de URL, solicitudes HTTP, manejo de JSON y análisis de datos con pandas.
Configura tu token de API y el ID del dataset de Instagram.
Configura el proxy para el scraping de Instagram.
Define los parámetros de búsqueda: KEYWORD, el número de publicaciones a recuperar (NUM_POSTS) y la ventana de fechas (DATE_START → DATE_END).

Paso 2: Encontrar publicaciones de Instagram a través de 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 URL de las publicaciones de Instagram del HTML, las normaliza (www.instagram.com vs instagram.com) y elimina los duplicados.
Se detiene cuando ha recopilado NUM_POSTS URL únicas o cuando alcanza el número máximo de páginas de resultados de Google.

Paso 3: Envío de URL 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 URL de Instagram recopiladas al dataset de Instagram en una sola 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 completa el procesamiento.

Paso 3: Consultar los resultados y guardar los 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')

No te pierdas nuestros análisis comparativos e insights basados en datos. El botón abre Google; seleccionar AIMultiple confirma que deseas ver AIMultiple con más frecuencia en los resultados de búsqueda de Google.

Añadir como fuente preferida

Scraper de comentarios de Instagram (Python)

Paso 1: Configuración e instalació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 librerías para el manejo de URL, expresiones regulares, solicitudes HTTP y pandas.
Configura tu ID del dataset 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 a través de 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í tú:

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 URL de las publicaciones de Instagram con regex, las desduplicas y te detienes una vez que tengas NUM_POSTS publicaciones.
Almacenas la lista final en instagram_urls, que alimentará el scraper de comentarios.

Paso 3: Envío de URL 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 URL de Instagram al dataset 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: Consultar los resultados y guardar los datos de los 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 consulta la API cada 10 segundos hasta que el scraping se completa. Una vez listo, recupera todos los datos de los 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.

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

Los scripts simples de Python que utilizan requests fallan inmediatamente porque carecen del comportamiento de un navegador real y dependen de una sola IP que se bloquea en minutos. La plataforma puede detectar scrapers web de Instagram al instante a través de múltiples capas de defensa:

Sin ejecución de JavaScript: Instagram carga la página dinámicamente, 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 velocidad: Los usuarios humanos no hacen 50 solicitudes por segundo. Los scrapers básicos reintentan con un ritmo predecible, e Instagram bloquea esto inmediatamente.
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 free; estos se bloquean después de unas pocas solicitudes.

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

Proxies, límites de velocidad 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 velocidad, introducir retrasos y evitar las solicitudes directas a Instagram. Así es como usamos 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:

durmiendo entre páginas de búsqueda de Google (time.sleep(2))
consultando las APIs cada 10 segundos,
nunca golpeando Instagram directamente.

Scrapers de Instagram utilizados en el benchmark

Nuestro benchmark probó las soluciones de API dedicadas de scraper de Instagram que se enumeran a continuación. Para obtener más información, consulta la benchmark metodología 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	❌	Scraping de Redes Sociales API – instagram_grap hql_post	❌
Perfil de Instagram	apify/instagram-profile-scraper	Instagram – Profiles – collect by URL	❌	Scraping de Redes Sociales 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 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 disponibles públicamente en Instagram está permitido siempre que respetes los términos de la plataforma y las leyes aplicables para el análisis de la competencia, la monitorización de la marca y el análisis de sentimientos. Sin embargo, siempre:

* Sigue los Términos de Uso de Instagram
* Evita recopilar datos personales que no estén destinados a ser públicos
* Utiliza una herramienta de scraping de Instagram que cumpla con las regulaciones regionales

Puedes scrapear 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 interacció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 golpear Instagram directamente y utiliza una API de scraping que maneja el bloqueo, los límites de velocidad y el fingerprinting por nosotros.

Los endpoints de la API de Instagram, como la Instagram Graph API, no proporcionan los datos públicos de perfil, publicación y comentarios que scrapeamos en este tutorial. Funciona para tu propia cuenta de empresa y requiere permisos y revisión de la aplicación, por lo que dependemos de las 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) - "Mejores scrapers de Instagram para extraer datos de Instagram". Publicado en línea en AIMultiple.com. Recuperado el 1 de Julio de 2026, de: https://aimultiple.com/instagram-scraping [Recurso en línea]

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

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

Enlaces de referencia

Instagram

Gulbahar Karatas

Analista de la industria

Gülbahar es analista del sector en AIMultiple, especializado en la recopilación de datos web, las aplicaciones de datos web y la seguridad de las aplicaciones.

Ver perfil completo