Análisis

Extraer datos de Twitter (X.com) con Python

actualizado el 13 de may. de 2026

Las plataformas de redes sociales, como X.com, emplean estrictas defensas contra el scraping, incluyendo CAPTCHA, límites de velocidad y bloqueo de IP. Estas medidas de seguridad hacen que construir un scraper personalizado desde cero sea difícil y propenso a interrupciones frecuentes.

Esta guía utiliza la API de scraper de Twitter, que permite una extracción fiable y conforme de datos de Twitter gestionando la rotación de proxies y la recopilación ética de datos.

Cómo extraer datos de Twitter usando Python

Paso 1: Configura tu entorno para el scraping web de Twitter

Antes de comenzar a extraer datos de Twitter, necesitarás preparar tu entorno de Python.

En este paso, importarás las bibliotecas necesarias, añadirás tus API credenciales (usamos la Bright Data scraper de Twitter API), configurarás un proxy y definirás tus parámetros de búsqueda.

1import requests
2import urllib.parse
3import re
4import time
5import json
6import pandas as pd
7import urllib3
8
9urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
10
11API_TOKEN = "YOUR_BRIGHTDATA_API_TOKEN"
12X_DATASET_ID = "DATASET_ID_YOU_GET_FROM_BRIGHTDATA"
13
14proxy = {
15    "http": "YOUR_PROXY_ADDRESS',
16    "https": 'YOUR_PROXY_ADDRESS"
17}
18
19KEYWORD = "ai agent optimizing"
20NUM_POSTS = 5

Estás preparando tu espacio de trabajo para que tu script de Python de scraping de Twitter pueda ejecutarse sin problemas y conectarse al scraper.

Importa las bibliotecas que usarás para las solicitudes, el análisis de datos y el guardado de resultados.
Añade tus credenciales, encontrarás el token de API y el ID del conjunto de datos en tu panel de control.
Configura un proxy para enrutar tu tráfico de forma segura y evitar bloqueos de IP mientras haces scraping de contenido de Twitter.
Establece tu palabra clave y límite. En este ejemplo, estás rastreando "AI agent optimizing" y recopilando cinco publicaciones, pero puedes aumentar NUM_POSTS para ampliar el alcance de tu extracción de datos de Twitter.

Paso 2: Encuentra URLs de publicaciones de X para extraer

En este paso, usarás la búsqueda de Google para recopilar enlaces públicos de publicaciones de X (tweets) que coincidan con tu palabra clave. Este truco simple te permite extraer datos de Twitter sin acceso a la API consultando URLs de X/Twitter.

1all_urls = []
2start = 0
3max_pages = 5
4
5while len(all_urls) < NUM_POSTS and start < max_pages * 10:
6    query = f"site:x.com OR site:twitter.com {KEYWORD}"
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://x.com/[^/]+/status/[0-9]+',
20        r'https://twitter.com/[^/]+/status/[0-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]
30            clean_url = clean_url.replace('twitter.com', 'x.com')
31
32            if clean_url not in seen_urls:
33                seen_urls.add(clean_url)
34                found_urls.append(clean_url)
35
36    if not found_urls:
37        break
38
39    for found_url in found_urls:
40        if found_url not in all_urls:
41            all_urls.append(found_url)
42        if len(all_urls) >= NUM_POSTS:
43            break
44
45    if len(all_urls) >= NUM_POSTS:
46        break
47
48    start += 10
49    time.sleep(2)
50
51x_urls = all_urls[:NUM_POSTS]
52
53if not x_urls:
54    print("No X posts found!")
55    exit()

Este script construye una consulta de Google, como 'site:x.com OR site:twitter.com ', para devolver publicaciones de X/Twitter. Extrae las URLs de los tweets, las limpia, convierte los enlaces antiguos de twitter.com a x.com y elimina duplicados.

Se incluye un retraso de 2 segundos entre las solicitudes para respetar los servidores de Google mientras se recopilan suficientes URLs únicas para tu flujo de trabajo de extracción de datos de Twitter.

Paso 3: Activa el scraping de Twitter

Envía las URLs recopiladas al scraper.

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

Una vez que hayamos recopilado todas las URLs de las publicaciones de X, necesitamos enviarlas al scraper web para la extracción de datos. Esta sección realiza una solicitud POST al endpoint de activación de Bright Data con nuestro token de autenticación y el ID del conjunto de datos. El mismo método que utilizan muchas tuberías de scraping web de Twitter al gestionar la recopilación de datos externa.

Las URLs se formatean como una lista de objetos JSON, donde cada objeto contiene una sola URL de publicación. Cuando la API recibe esta solicitud correctamente, devuelve un ID de instantánea, que actúa como referencia para este trabajo de scraping en particular.

Si la llamada a la API falla por cualquier motivo, el script termina con un mensaje de error. Este paso forma la base del scraping de datos de Twitter, un enfoque escalable y conforme para cualquiera que aprenda a extraer datos de Twitter de forma segura y eficiente sin depender de la API oficial.

Paso 4: Código completo y guarda los datos extraídos de X.com

1snapshot_url = f"BRIGHTDATA_API_SNAPSHOT_ENDPOINT/{snapshot_id}"
2headers = {"Authorization": f"Bearer {API_TOKEN}"}
3
4start_time = time.time()
5max_wait_seconds = 15 * 60
6
7while True:
8    elapsed = time.time() - start_time
9    if elapsed > max_wait_seconds:
10        print("Timeout!")
11        exit()
12
13    try:
14        response = requests.get(snapshot_url, headers=headers)
15
16        try:
17            data = response.json()
18            status = data.get("status")
19
20            if status == "ready" or status == "done":
21                download_url = data.get("download_url")
22                if download_url:
23                    download_response = requests.get(download_url)
24
25                    items = []
26                    for line in download_response.text.strip().split('\n'):
27                        if line.strip():
28                            try:
29                                items.append(json.loads(line))
30                            except:
31                                pass
32
33                    if items:
34                        break
35
36                items = data.get("items", [])
37                break
38
39            elif status == "failed":
40                print("Scraping failed")
41                exit()
42
43        except json.JSONDecodeError:
44            items = []
45            for line in response.text.strip().split('\n'):
46                if line.strip():
47                    try:
48                        items.append(json.loads(line))
49                    except:
50                        pass
51
52            if items:
53                break
54
55            time.sleep(10)
56
57    except Exception as e:
58        time.sleep(10)
59
60if not items:
61    print("No data received")
62    exit()
63
64print(f"\n{'='*80}")
65print(f"RESULTS: {len(items)} X POSTS")
66print(f"{'='*80}\n")
67
68for i, item in enumerate(items[:5], 1):
69    url = item.get('url', 'N/A')
70    description = item.get('description', 'N/A')
71
72    try:
73        likes = int(item.get('likes', 0))
74    except (ValueError, TypeError):
75        likes = 0
76
77    try:
78        views = int(item.get('views', 0))
79    except (ValueError, TypeError):
80        views = 0
81
82    try:
83        reposts = int(item.get('retweets', 0))
84    except (ValueError, TypeError):
85        reposts = 0
86
87    try:
88        replies = int(item.get('replies', 0))
89    except (ValueError, TypeError):
90        replies = 0
91
92    hashtags = item.get('hashtags', [])
93
94    print(f"POST #{i}")
95    print(f"  URL: {url}")
96    print(f"  Description: {description}")
97    print(f"  Likes: {likes}")
98    print(f"  Views: {views}")
99    print(f"  Reposts: {reposts}")
100    print(f"  Replies: {replies}")
101    print(f"  Hashtags: {hashtags}")
102    print()
103
104csv_data = []
105for item in items:
106    try:
107        likes = int(item.get('likes', 0))
108    except (ValueError, TypeError):
109        likes = 0
110
111    try:
112        views = int(item.get('views', 0))
113    except (ValueError, TypeError):
114        views = 0
115
116    try:
117        reposts = int(item.get('retweets', 0))
118    except (ValueError, TypeError):
119        reposts = 0
120
121    try:
122        replies = int(item.get('replies', 0))
123    except (ValueError, TypeError):
124        replies = 0
125
126    hashtags = item.get('hashtags', [])
127    hashtags_str = ','.join(hashtags) if isinstance(hashtags, list) else str(hashtags)
128
129    csv_data.append({
130        'description': item.get('description', 'N/A'),
131        'url': item.get('url', 'N/A'),
132        'likes': likes,
133        'views': views,
134        'reposts': reposts,
135        'replies': replies,
136        'hashtags': hashtags_str
137    })
138
139df = pd.DataFrame(csv_data)
140df.to_csv('x_ai_agent_optimizing_posts.csv', index=False, encoding='utf-8-sig')
141
142print(f"\n{'='*80}")
143print("SAVED TO: x_ai_agent_optimizing_posts.csv")
144print(f"{'='*80}")

La sección final espera a que el scraper termine y luego recupera los resultados para tu flujo de trabajo de scraping web de Twitter. Dado que el scraping puede llevar tiempo, tu script consulta el estado de la instantánea cada 10 segundos con un tiempo de espera de 15 minutos. Cuando el estado se vuelve "listo" o "terminado", descarga el conjunto de datos a través de la URL proporcionada.

La respuesta llega como NDJSON, por lo que cada línea se analiza en un diccionario de Python. Después de recopilar todos los datos, el script imprime la URL, la descripción y las métricas de participación (me gusta, vistas, republicaciones, respuestas, hashtags) de cada publicación. Finalmente, todo se organiza en un DataFrame de pandas y se exporta a CSV para informes o modelado.

Los bloques try/except aseguran que los campos numéricos se conviertan de forma segura (manejando formatos inesperados), lo que hace que este enfoque sea fiable para tuberías de scraping de datos de Twitter y tutoriales sobre cómo extraer datos de Twitter sin la API oficial.

Benchmark: Rendimiento y fiabilidad (herramienta de pago vs código abierto)

Executamos tres configuraciones con los mismos temas:

Una herramienta de pago (proveedor de scraping gestionado)
SN-Scraper (código abierto)
Un script personalizado de navegador sin cabeza. Cada uno recopiló publicaciones públicas, analizó la participación y guardó los datos en un CSV.

Lo que observamos:

Rendimiento (tweets/min): scrapers de Twitter de pago > navegador sin cabeza > SN-Scraper.
Tasa de éxito: La herramienta de pago manejó los cambios de diseño/autenticación de manera más consistente.
Tiempo de ingeniería: las opciones de código abierto necesitaron más parches después de los cambios del sitio.

Para el scraping continuo de datos de Twitter, las herramientas de scraping web de pago pueden reducir los fallos y los costos ocultos, especialmente cuando necesitas extraer datos de Twitter de forma continua o en muchos temas.

Mejores prácticas para el scraping de Twitter

Los siguientes puntos estabilizan tus ejecuciones de scraping de Twitter en Python y reducen los bloqueos.

Ritmo: Mantén un retraso de 2 segundos en el descubrimiento de Google y aumenta gradualmente la duración del tiempo de espera (10→20→40s) en los siguientes tiempos de espera.
Rotar identidades: Usa IPs/user-agents rotativos (una herramienta de pago suele automatizar esto) para extraer datos de Twitter a escala.
Limita la concurrencia: Inicia 3-5 trabajadores; aumenta si la tasa de error se mantiene baja.
Caché y deduplicación: No vuelvas a recuperar la misma publicación; guarda los IDs y la marca de tiempo de la última vista.
Distribuye los horarios: Extiende las ejecuciones a lo largo del día.

Agregador de Twitter (programación + paneles de control)

Una vez que tu scraper de Twitter en Python esté funcionando, puedes evolucionarlo fácilmente en un agregador de Twitter que recopile y visualice continuamente publicaciones públicas de X.com en torno a temas específicos, hashtags o influencers. Un agregador es un sistema automatizado que:

Recopila publicaciones de múltiples fuentes o palabras clave
Limpia y almacena los datos regularmente (cada hora o diariamente)
Muestra información en un panel de control para un análisis rápido

Tu tutorial de 4 pasos realiza todas las funciones principales: descubrimiento, scraping y exportación, lo que lo convierte en una base adecuada para un agregador automatizado.

Cómo construir tu agregador de Twitter

Programa ejecuciones regulares: Usa un trabajo cron o un planificador de flujo de trabajo para ejecutar tu script automáticamente (por ejemplo, cada hora). Rota a través de una lista de temas o hashtags cada vez.
Deduplica y añade nuevos datos: Después de cada ejecución, verifica duplicados usando URL o ID y añade publicaciones frescas a tu CSV o base de datos. Organiza los resultados por día (/data/x_posts/YYYY-MM-DD/) para que sean fáciles de consultar más tarde.
Transforma para paneles de control: Carga tus CSVs en Google Data Studio, Tableau o notebooks de Python para visualizar:
- Volumen de publicaciones por hora/día
- Principales autores o hashtags
- Tendencias de participación (me gusta, vistas, republicaciones)

article.automate_process_description

article.automate_process_button

Usa patrones de consulta como un buscador de Twitter (personas y publicaciones)

Tu paso de descubrimiento puede hacer más que encontrar publicaciones. Puede ayudarte a encontrar personas, influencers y cuentas clave en X.com usando operadores de búsqueda de Google. Esto hace que tu scraper funcione también como un buscador de Twitter tanto para perfiles de usuario como para tweets relacionados con temas.

¿Qué es un buscador de Twitter?

Un buscador de Twitter es un flujo de trabajo de búsqueda que identifica:

Personas o perfiles basados en título laboral, biografía o palabras clave de la industria
Tweets o publicaciones basados en temas específicos, hashtags o marcos temporales

Aún dependerás del operador site:x.com de Google para descubrir páginas públicas que coincidan con tus palabras clave, sin requerir la API de Twitter.

Patrones de consulta para encontrar perfiles:

Estos patrones te ayudan a recopilar páginas de autores (no tweets). Introduce esas URLs en tu scraper para extraer campos como user_posted, name, followers, is_verified y biography. Para localizar perfiles, prueba:

1site:x.com "@<name>" -inurl:/status
2site:x.com "<role>" "<company>" -inurl:/status
3site:x.com "bio keyword" -inurl:/status
4

Esto transforma tu proyecto en un scraper de perfiles de Twitter sencillo, ideal para el descubrimiento de influencers, reclutamiento o investigación de marketing.

Patrones de consulta para encontrar publicaciones:

Para centrarte en tweets o publicaciones, usa:

1site:x.com "<keyword>" OR "<hashtag>"
2site:x.com "<topic>" after:2025-01-01
3

Estas técnicas mejoran tanto el recuerdo (mostrando más tweets relevantes) como la precisión (reduciendo el número de resultados irrelevantes). Al aplicar estos trucos de consulta, tu scraper se convierte en un buscador de Twitter preciso.

Soluciona problemas de vistas previas faltantes con un depurador de Twitter (consejos de metadatos)

Los usuarios del depurador de Twitter a menudo quieren arreglar las vistas previas de enlaces (Tarjetas de Twitter/Open Graph). Aunque no es scraping, es adyacente y útil.

Asegúrate de que las páginas objetivo incluyan og:title, og:description, og:image y el meta twitter:card correcto.
Verifica que las imágenes sean HTTPS, accesibles y estén dentro de los límites de tamaño.
Vuelve a compartir después de las actualizaciones de metadatos.

¿Es legal extraer datos de Twitter/X?

Los Términos de Servicio de X prohíben el rastreo o scraping del servicio sin consentimiento por escrito. El contenido visible públicamente en X no está automáticamente disponible para la recopilación automatizada. Las empresas deben revisar los Términos de X, las leyes de privacidad y las regulaciones de propiedad intelectual antes de recopilar datos fuera de los canales oficiales.

El riesgo legal depende del tipo y volumen de datos recopilados. También depende de si se eluden controles de acceso o inicio de sesión, si se involucran datos personales, cómo se almacenan o comparten los datos y si el recopilador tiene permiso.

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

API oficial de X vs scraping web

La API v2 de X utiliza un modelo de precios basado en el uso, con costos determinados por los recursos accedidos a través de llamadas de API. Según la documentación de X, cada operación de lectura, publicación, usuario, seguidor, lista, medio y tendencia tiene un precio específico. Por ejemplo, leer una publicación cuesta $0.005, mientras que leer un usuario o seguidor/seguimiento cuesta $0.010 por recurso.¹

Sin embargo, puede volverse costoso para usos a gran escala, tiene límites en algunos endpoints y puede no satisfacer todas las necesidades históricas o de descubrimiento.

Tendencias recientes para el scraping web de Twitter

Scraping nativo de IA (integración de MCP)

Una tendencia importante en 2026 es pasar de herramientas de codificación tradicionales como Python y BeautifulSoup al Protocolo de Contexto de Modelo (MCP). En lugar de escribir y actualizar scripts, los usuarios solicitan los datos que necesitan, y la herramienta MCP se encarga de la extracción, limpieza y formateo.

Cambio a navegador completo

Los navegadores sin cabeza básicos como Puppeteer o Selenium son detectados rápidamente por la avanzada huella digital TLS de X. Como resultado, las principales empresas utilizan navegadores Stealth y Playwright con plugins que ejecutan sesiones completas del navegador.

Estas herramientas imitan acciones humanas, como mover el mouse aleatoriamente y cambiar los tiempos, para eludir los sistemas anti-bot de aprendizaje automático de X.

Preguntas frecuentes

Sí. Tu salida incluye campos de medios (por ejemplo, photos, videos, external_*). Guarda estas URLs y descárgalas más tarde si tu caso de uso lo requiere. Para escalar, guarda los enlaces, junto con metadatos (tamaño y tipo), para mantener bajos los costos de almacenamiento.

Usa residenciales o proxies ISP rotativos. Proporcionan una mejor reputación que los grupos básicos de centro de datos y reducen los bloqueos suaves. Si usas una herramienta de pago, la rotación de alta calidad suele estar incluida, útil para trabajos de scraping de Twitter de larga duración.

Si tu enfoque es el medio, el mismo flujo se convierte en un scraper de medios de Twitter que captura enlaces de imágenes/videos a escala. Cómo adaptar tu tubería:

* Mantén el descubrimiento de palabras clave del paso 2, pero sesga las consultas hacia publicaciones ricas en medios: "tema" (photo OR video) site:x.com. En tus resultados, lee photos, videos, external_image_urls y external_video_urls.

* Guarda URLs, no binarios. Descargar medios puede ser un segundo trabajo limitado por la tasa (cola paralela, suma de comprobación, reintentos).

Cita esta investigación

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.

Cem Dilmegani (2026) - "Extraer datos de Twitter (X.com) con Python". Publicado en línea en AIMultiple.com. Recuperado el 13 de Mayo de 2026, de: https://aimultiple.com/twitter-web-scraping [Recurso en línea]

Dilmegani, C. (2026, 13 de Mayo). Extraer datos de Twitter (X.com) con Python. AIMultiple. https://aimultiple.com/twitter-web-scraping

@misc{dilmegani2026,
  author = {Dilmegani, Cem},
  title  = {{Extraer datos de Twitter (X.com) con Python}},
  year   = {2026},
  month  = may,
  howpublished    = {\url{https://aimultiple.com/twitter-web-scraping}},
  note   = {AIMultiple. Recuperado el 13 de Mayo de 2026}
}

Enlaces de referencia

Pricing - X

Cem Dilmegani

Analista principal

Cem ha sido el analista principal de AIMultiple desde 2017. AIMultiple informa a cientos de miles de empresas (según similarWeb), incluyendo el 55% de las empresas Fortune 500 cada mes. El trabajo de Cem ha sido citado por importantes publicaciones globales como Business Insider, Forbes, Washington Post, firmas globales como Deloitte, HPE y ONG como el Foro Económico Mundial y organizaciones supranacionales como la Comisión Europea. Puede consultar más empresas y recursos de renombre que citan a AIMultiple. A lo largo de su carrera, Cem se desempeñó como consultor, comprador y emprendedor tecnológico. Asesoró a empresas en sus decisiones tecnológicas en McKinsey & Company y Altman Solon durante más de una década. También publicó un informe de McKinsey sobre digitalización. Lideró la estrategia y adquisición de tecnología de una empresa de telecomunicaciones, reportando directamente al CEO. Asimismo, lideró el crecimiento comercial de la empresa de tecnología avanzada Hypatos, que alcanzó ingresos recurrentes anuales de siete cifras y una valoración de nueve cifras partiendo de cero en tan solo dos años. El trabajo de Cem en Hypatos fue reseñado por importantes publicaciones tecnológicas como TechCrunch y Business Insider. Cem participa regularmente como ponente en conferencias internacionales de tecnología. Se graduó en ingeniería informática por la Universidad de Bogazici y posee un MBA de la Columbia Business School.

Ver perfil completo

Comentarios 1

Comparte tus ideas

Tu dirección de correo electrónico no será publicada. Todos los campos son obligatorios. Los comentarios se dejan en su idioma original.

Jones

Sep 20, 2023 at 12:10

You cannot access tweets for free using the API. Twitter (X) charges developers at minimum $100/month to use the API to access tweets. The free developer option is limited to posting only, which is not what you'd want to scrape Twitter for anyway.