Mi extractor de reseñas de Amazon funcionó de maravilla durante seis semanas; luego, una mañana, devolvió 200 OK y una página totalmente vacía. Sin error, sin CAPTCHA, solo HTML en blanco donde antes había cientos de reseñas.
Si te suena, no eres el único. A finales de 2025, Amazon empezó a poner sus páginas completas de reseñas detrás de un muro de inicio de sesión, y una enorme cantidad de scripts de scraping en Python dejaron de funcionar de la noche a la mañana. He pasado los últimos meses en Thunderbit trabajando el problema desde los dos lados —desarrollando nuestro AI web scraper y manteniendo también mi propio pipeline de reseñas en Python—, así que pensé que ya iba siendo hora de escribir la guía que me habría gustado tener cuando mi script se quedó a oscuras. Este artículo cubre el enfoque que sí funciona: autenticación basada en cookies, selectores estables que sobreviven a la ofuscación CSS de Amazon, trucos para esquivar el límite de paginación de 10 páginas, defensas anti-bots y, como extra, una sección de análisis de sentimiento que convierte texto bruto en insights de negocio reales. Y si a mitad de camino piensas: "Prefiero no mantener todo este código", te mostraré cómo Thunderbit hace lo mismo en unos dos minutos, sin necesidad de Python.
¿Qué es el scraping de reseñas de Amazon y por qué importa?
El scraping de reseñas de Amazon es el proceso de extraer de forma programática datos de opiniones de clientes —valoraciones por estrellas, texto de la reseña, nombre del autor, fecha, distintivo de compra verificada— desde páginas de productos de Amazon. Como Amazon eliminó el contenido de reseñas de su Product Advertising API en 2010 (y nunca lo volvió a poner), el web scraping es la única vía programática para acceder a estos datos.
Los números lo respaldan. El 95% de los compradores lee reseñas antes de comprar y el 94% señala Amazon como su principal fuente de opiniones sobre productos. Mostrar solo 5 reseñas en una página de producto puede aumentar la conversión un 270%. Las empresas que analizan sistemáticamente el sentimiento de las reseñas ven hasta un 15% más de retención de clientes. Esto no es ciencia de datos abstracta: es inteligencia competitiva, señales para mejorar productos y lenguaje de marketing, todo visible en texto plano en los servidores de Amazon.
Por qué extraer reseñas de Amazon con Python
Python sigue siendo el lenguaje preferido para este trabajo. Es el lenguaje más deseado en la encuesta Stack Overflow Developer Survey 2024, y su ecosistema —requests, BeautifulSoup, pandas, Scrapy— hace que el web scraping sea accesible incluso para personas que no son desarrolladoras a tiempo completo.
Distintos equipos aprovechan estos datos de maneras distintas:
| Equipo | Caso de uso | Qué extraen |
|---|---|---|
| Producto / I+D | Detectar quejas repetidas y priorizar mejoras | Texto de reseñas de 1–2 estrellas, frecuencia de palabras clave |
| Ventas | Vigilar el sentimiento frente a productos de la competencia | Valoraciones, tendencias de volumen de reseñas |
| Marketing | Sacar lenguaje real de clientes para copys publicitarios | Frases positivas, menciones de funciones |
| Operaciones Ecommerce | Seguir cómo evoluciona el sentimiento de un producto propio | Distribución de estrellas, ratio de compras verificadas |
| Investigación de mercado | Comparar líderes de categoría en distintas funciones | Conjuntos de reseñas de varios ASIN |
Una marca de utensilios de cocina analizó reseñas negativas y descubrió que el 22% mencionaba que "el recubrimiento antiadherente se desgasta", reformuló el producto y recuperó el puesto #1 de Best Seller en 60 días. Una empresa de pulseras de fitness detectó "irritación con la correa" en el texto de reseñas, identificó un problema de alergia al látex, lanzó una versión hipoalergénica y redujo devoluciones un 40%. Este es el tipo de ROI que hace que el esfuerzo de ingeniería valga la pena.
Muro de inicio de sesión: por qué dejó de funcionar tu scraper de reseñas de Amazon
El 14 de noviembre de 2024, Amazon empezó a exigir inicio de sesión para ver la página completa de reseñas de producto. El cambio fue confirmado en foros de la comunidad y blogs de proveedores de scraping. Si visitas /product-reviews/{ASIN}/ en una ventana de incógnito, serás redirigido a una página de acceso en lugar de ver las reseñas.
Los síntomas son sutiles: tu script recibe una respuesta 200 OK, pero el cuerpo HTML contiene un formulario de inicio de sesión (name="email", id="ap_password") en lugar de reseñas. Sin código de error. Sin CAPTCHA. Solo... nada útil.
Amazon hizo esto por motivos de anti-bot y cumplimiento regional. La aplicación es inconsistente —a veces una ventana nueva del navegador carga unas cuantas reseñas antes de aparecer el muro, especialmente en la primera página—, pero para cualquier scraper que funcione a escala, debes asumir que el muro está siempre activo.
Los distintos dominios de Amazon por país (.de, .co.uk, .co.jp) aplican el bloqueo de forma independiente. Como dijo un usuario en un foro: "se requiere un inicio de sesión para cada país". Tus cookies de .com no funcionarán en .co.uk.
Reseñas destacadas vs. reseñas completas: qué sigue accesible sin login
Las páginas de producto de Amazon (la URL /dp/{ASIN}/) siguen mostrando unas 8 "reseñas destacadas" sin autenticación. Están seleccionadas por el algoritmo de Amazon y sirven para una comprobación rápida del sentimiento, pero no se pueden ordenar, filtrar ni paginar.
Las páginas completas de reseñas (/product-reviews/{ASIN}/) —con ordenación por más recientes, filtrado por valoración y paginación entre cientos de reseñas— requieren inicio de sesión.
Si solo necesitas unas pocas reseñas para una lectura rápida del pulso, extrae la página de producto. Para cientos o miles, tendrás que gestionar la autenticación.
Lo que necesitas antes de empezar: configuración de Python y librerías
Antes de escribir código, esta es la preparación:
- Dificultad: Intermedia (comodidad con Python y conocimientos básicos de HTML)
- Tiempo necesario: ~45 minutos para el pipeline completo; ~10 minutos para una extracción básica
- Lo que necesitarás: Python 3.8+, navegador Chrome, una cuenta válida de Amazon
Instala las librerías principales:
pip install requests beautifulsoup4 lxml pandas textblob
Opcional (para análisis de sentimiento avanzado):
pip install transformers torch
¿Qué es un ASIN? Es el identificador de producto de 10 caracteres de Amazon. Lo encontrarás en cualquier URL de producto —por ejemplo, en amazon.com/dp/B0BCNKKZ91, el ASIN es B0BCNKKZ91. Esa es la clave que usarás en la URL de reseñas.
Paso 1: superar el muro de inicio de sesión con autenticación basada en cookies
La forma más fiable es iniciar sesión en Amazon en tu navegador, copiar tus cookies de sesión e inyectarlas en tu requests.Session() de Python. Así evitas desencadenar CAPTCHAs y la 2FA por SMS que suelen complicar la automatización con Selenium.
Necesitas estas siete cookies:
| Nombre de la cookie | Propósito |
|---|---|
session-id | Identificador de sesión rotatorio |
session-id-time | Marca temporal de la sesión |
session-token | Token de sesión rotatorio |
ubid-main | Identificador de navegación del usuario |
at-main | Token de autenticación principal |
sess-at-main | Autenticación limitada a la sesión |
x-main | Identificador vinculado al correo del usuario |
Cómo extraer cookies desde Chrome DevTools
- Inicia sesión en amazon.com en Chrome
- Abre DevTools (F12 o clic derecho → Inspeccionar)
- Ve a Application → Storage → Cookies →
https://www.amazon.com - Busca cada cookie en la tabla y copia su valor
- Formátalas como una cadena separada por punto y coma para Python
Configura tu sesión así:
import requests
session = requests.Session()
# Pega aquí los valores de tus cookies
cookies = {
"session-id": "YOUR_SESSION_ID",
"session-id-time": "YOUR_SESSION_ID_TIME",
"session-token": "YOUR_SESSION_TOKEN",
"ubid-main": "YOUR_UBID_MAIN",
"at-main": "YOUR_AT_MAIN",
"sess-at-main": "YOUR_SESS_AT_MAIN",
"x-main": "YOUR_X_MAIN",
}
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.5",
}
session.cookies.update(cookies)
session.headers.update(headers)
Importante: reutiliza el mismo objeto session en todas las solicitudes. Esto mantiene las cookies coherentes y simula una sesión real de navegador. Las cookies suelen durar de días a semanas bajo carga de scraping, pero si vuelves a ver redirecciones a la página de acceso, actualízalas desde el navegador.
Para mercados que no sean .com, los nombres de cookies cambian ligeramente: amazon.de usa at-acbde en lugar de at-main, amazon.co.uk usa at-acbuk, y así sucesivamente. Cada marketplace necesita su propia sesión independiente.
Paso 2: construir la solicitud y parsear el HTML de reseñas con BeautifulSoup
La URL de reseñas de Amazon sigue este patrón:
https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1
La función principal:
from bs4 import BeautifulSoup
import time, random
def get_soup(session, url):
time.sleep(random.uniform(2, 5)) # Pausa respetuosa
response = session.get(url, timeout=15)
# Detectar muro de login
if "ap_email" in response.text or "Amazon Sign-In" in response.text:
raise Exception("Se detectó el muro de inicio de sesión — actualiza tus cookies")
if response.status_code != 200:
raise Exception(f"HTTP {response.status_code}")
return BeautifulSoup(response.text, "lxml")
Hay un truco pequeño pero útil: antes de entrar en la página de reseñas, visita primero la página del producto. Eso establece un patrón de navegación más natural en tu sesión.
# Visita primero la página del producto (simula navegación real)
product_url = f"https://www.amazon.com/dp/{asin}"
session.get(product_url, timeout=15)
time.sleep(random.uniform(1, 3))
# Luego entra en la página de reseñas
reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
soup = get_soup(session, reviews_url)
Paso 3: usar selectores estables para extraer datos de reseñas (deja de depender de clases CSS)
Aquí es donde fallan la mayoría de los tutoriales de 2022–2023. Amazon ofusca los nombres de las clases CSS: cambian periódicamente y, como dijo un desarrollador frustrado en un hilo de foro: "ninguno tenía un patrón único para los nombres de las clases de las etiquetas span".
La solución: Amazon usa atributos data-hook en los elementos de reseñas, y estos son sorprendentemente estables. Son identificadores semánticos de los que depende el frontend de Amazon, así que no se randomizan.
| Campo de la reseña | Selector estable (data-hook) | Selector frágil (class) |
|---|---|---|
| Texto de la reseña | [data-hook="review-body"] | .review-text-content (cambia) |
| Valoración por estrellas | [data-hook="review-star-rating"] | .a-icon-alt (ambiguo) |
| Título de la reseña | [data-hook="review-title"] | .review-title (a veces) |
| Nombre del autor | span.a-profile-name | Relativamente estable |
| Fecha de la reseña | [data-hook="review-date"] | .review-date (depende de la región) |
| Compra verificada | [data-hook="avp-badge"] | span.a-size-mini |
El código de extracción usando selectores data-hook:
import re
def extract_reviews(soup):
reviews = []
review_divs = soup.select('[data-hook="review"]')
for div in review_divs:
# Valoración
rating_el = div.select_one('[data-hook="review-star-rating"]')
rating = None
if rating_el:
rating_text = rating_el.get_text(strip=True)
match = re.search(r'(\d\.?\d?)', rating_text)
if match:
rating = float(match.group(1))
# Título
title_el = div.select_one('[data-hook="review-title"]')
title = title_el.get_text(strip=True) if title_el else ""
# Cuerpo
body_el = div.select_one('[data-hook="review-body"]')
body = body_el.get_text(strip=True) if body_el else ""
# Autor
author_el = div.select_one('span.a-profile-name')
author = author_el.get_text(strip=True) if author_el else ""
# Fecha y país
date_el = div.select_one('[data-hook="review-date"]')
date_text = date_el.get_text(strip=True) if date_el else ""
# Formato: "Reviewed in the United States on January 15, 2025"
country_match = re.search(r'Reviewed in (.+?) on', date_text)
date_match = re.search(r'on (.+)$', date_text)
country = country_match.group(1) if country_match else ""
date = date_match.group(1) if date_match else ""
# Compra verificada
verified_el = div.select_one('[data-hook="avp-badge"]')
verified = bool(verified_el)
reviews.append({
"author": author,
"rating": rating,
"title": title,
"content": body,
"date": date,
"country": country,
"verified": verified,
})
return reviews
Llevo meses ejecutando este conjunto de selectores contra varios ASIN y los atributos data-hook no han cambiado ni una vez. Las clases CSS, en cambio, han rotado al menos dos veces en el mismo periodo.
Paso 4: gestionar la paginación y el límite de 10 páginas de Amazon
Amazon limita el parámetro pageNumber a 10 páginas de 10 reseñas cada una: un techo fijo de unas ~100 reseñas por combinación de filtro. El botón "Siguiente" desaparece después de la página 10.
Bucle básico de paginación:
all_reviews = []
for page in range(1, 11):
url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break # No hay más reseñas en esta página
all_reviews.extend(page_reviews)
print(f"Página {page}: {len(page_reviews)} reseñas")
Cómo obtener más de 10 páginas de reseñas de Amazon
El truco es agrupar por filtros. Cada combinación de filterByStar y sortBy obtiene su propia ventana independiente de 10 páginas.
Valores del filtro por estrellas: one_star, two_star, three_star, four_star, five_star
Valores de ordenación: recent, helpful (predeterminado)
Combinando los 5 filtros de estrellas × 2 órdenes de ordenación, puedes acceder hasta a 100 páginas, es decir, 1.000 reseñas por producto; y en productos con distribución desigual de estrellas, muchas veces te acercarás bastante al conjunto completo.
star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
sort_orders = ["recent", "helpful"]
all_reviews = []
seen_titles = set() # Deducción simple
for star in star_filters:
for sort in sort_orders:
for page in range(1, 11):
url = (
f"https://www.amazon.com/product-reviews/{asin}"
f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
)
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break
for review in page_reviews:
# Eliminar duplicados por combinación título + autor
key = (review["title"], review["author"])
if key not in seen_titles:
seen_titles.add(key)
all_reviews.append(review)
print(f"[{star}/{sort}] Página {page}: {len(page_reviews)} reseñas")
print(f"Total de reseñas únicas: {len(all_reviews)}")
Habrá solapamiento entre bloques, así que la deduplicación es esencial. Yo uso una combinación de título de reseña + nombre del autor como clave rápida; no es perfecta, pero detecta la gran mayoría de duplicados.
Paso 5: esquivar las defensas anti-bot (rotar, limitar, reintentar)
Amazon usa AWS WAF Bot Control y se ha vuelto bastante más agresivo. Las contramedidas de una sola capa (solo rotar User-Agents, solo añadir pausas) ya no bastan.
| Técnica | Implementación |
|---|---|
| Rotación de User-Agents | Selección aleatoria entre más de 10 cadenas reales de navegador |
| Backoff exponencial | Retrasos de reintento de 2s → 4s → 8s en respuestas 503 |
| Limitación de solicitudes | random.uniform(2, 5) segundos entre páginas |
| Rotación de proxies | Ciclo a través de proxies residenciales |
| Huella de sesión | Cookies + headers consistentes por sesión |
| Suplantación TLS | Usar curl_cffi en lugar de requests estándar para producción |
Un envoltorio de reintentos listo para producción:
import time, random
USER_AGENTS = [
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 15_7_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
]
def scrape_with_retries(session, url, max_retries=3):
for attempt in range(max_retries):
try:
session.headers["User-Agent"] = random.choice(USER_AGENTS)
time.sleep(random.uniform(2, 5))
response = session.get(url, timeout=15)
# Detectar bloqueos
if "validateCaptcha" in response.url or "Robot Check" in response.text:
wait = (2 ** attempt) * 5
print(f"CAPTCHA detectado. Esperando {wait}s...")
time.sleep(wait)
continue
if response.status_code in (429, 503):
wait = (2 ** attempt) * 2
print(f"Límite de tasa alcanzado ({response.status_code}). Esperando {wait}s...")
time.sleep(wait)
continue
if "ap_email" in response.text:
raise Exception("Muro de inicio de sesión — las cookies han caducado")
return BeautifulSoup(response.text, "lxml")
except Exception as e:
if attempt == max_retries - 1:
raise
print(f"El intento {attempt + 1} falló: {e}")
return None
Una nota sobre proxies: Amazon bloquea rangos de IP de centros de datos conocidos (AWS, GCP, Azure, DigitalOcean) a nivel de red. Si vas a extraer más de unos pocos cientos de páginas, los proxies residenciales son prácticamente obligatorios; espera gastar entre 50 y 200 USD/mes o más, según el volumen. Para proyectos pequeños (menos de 100 solicitudes/día), un throttling cuidadoso desde tu IP doméstica suele funcionar bien.
Amazon también inspecciona huellas TLS. La librería requests estándar de Python tiene un hash JA3 bien conocido que los WAF bloquean de antemano. Para scrapers de producción, considera curl_cffi, que se hace pasar por stacks TLS reales de navegador. Para scraping a escala de tutorial (unos pocos cientos de páginas), requests con buenos headers suele bastar.
Paso 6: exporta tus reseñas de Amazon a CSV o Excel
Una vez que hayas recopilado tus reseñas, llevarlas a un formato utilizable es sencillo con pandas:
import pandas as pd
df = pd.DataFrame(all_reviews)
df.to_csv("amazon_reviews.csv", index=False)
print(f"Se exportaron {len(df)} reseñas a amazon_reviews.csv")
Ejemplo de salida:
| author | rating | title | content | date | country | verified |
|---|---|---|---|---|---|---|
| Sarah M. | 5.0 | Best purchase this year | Battery lasts all day, screen is gorgeous... | January 15, 2025 | the United States | True |
| Mike T. | 2.0 | Disappointed after 2 weeks | The charging port stopped working... | February 3, 2025 | the United States | True |
| Priya K. | 4.0 | Great value for the price | Does everything I need, minor lag on heavy apps... | March 10, 2025 | the United States | False |
Para exportar a Excel: df.to_excel("amazon_reviews.xlsx", index=False) (requiere openpyxl).
Para Google Sheets, la librería gspread funciona, pero requiere más de 8 pasos de configuración en Google Cloud —crear un proyecto, habilitar dos APIs, generar credenciales de cuenta de servicio y compartir la hoja. Si eso te parece más trabajo que el scraping en sí, no vas desencaminado. (Este es uno de esos momentos en que una herramienta como Thunderbit, que exporta a Google Sheets con un clic, empieza a parecer muy atractiva.)
Extra: añade análisis de sentimiento a tus reseñas extraídas en 5 líneas de Python
La mayoría de los tutoriales de scraping se quedan en exportar CSV. Pero puntuar el sentimiento es lo que convierte datos brutos en decisiones de negocio.
La forma más rápida de empezar usa TextBlob:
from textblob import TextBlob
df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)
Eso te da una puntuación de polaridad de -1.0 (muy negativa) a +1.0 (muy positiva) para cada reseña. Ejemplo de salida:
| content (truncated) | rating | sentiment |
|---|---|---|
| "Battery lasts all day, screen is gorgeous..." | 5.0 | 0.65 |
| "The charging port stopped working after..." | 2.0 | -0.40 |
| "Does everything I need, minor lag on..." | 4.0 | 0.25 |
| "Absolute garbage. Returned immediately." | 1.0 | -0.75 |
| "It's okay. Nothing special but works." | 3.0 | 0.10 |
Las filas interesantes son las que no encajan: una reseña de 3 estrellas con texto muy positivo, o una de 5 estrellas con lenguaje negativo. Estas discrepancias suelen revelar opiniones matizadas que la valoración en estrellas por sí sola no muestra.
Para una precisión de nivel producción, la recomendación es Hugging Face Transformers. VADER fue entrenado con tweets, no con reseñas de productos, y los modelos Transformer alcanzan más del 98% de precisión en clasificación de reseñas frente a herramientas léxicas. El modelo nlptown/bert-base-multilingual-uncased-sentiment incluso predice directamente valoraciones de 1 a 5 estrellas:
from transformers import pipeline
clf = pipeline("sentiment-analysis",
model="nlptown/bert-base-multilingual-uncased-sentiment")
df["predicted_stars"] = df["content"].apply(
lambda x: int(clf(str(x)[:512])[0]["label"][0])
)
Las reseñas de Amazon siguen una distribución en forma de J: un gran pico en 5 estrellas, un pico más pequeño en 1 estrella y un valle en el medio. Esto significa que la valoración media suele ser un mal indicador de la calidad real del producto. Segmenta el grupo de 1 estrella y analiza temas recurrentes: normalmente ahí es donde se esconde un único defecto corregible.
La verdad incómoda: Python casero vs. APIs de scraping de pago vs. Thunderbit
He mantenido scrapers en Python para Amazon, y te seré sincero: se rompen. Cambian los selectores, caducan las cookies, Amazon lanza una nueva capa de detección de bots y, de repente, tu sábado por la mañana consiste en depurar un scraper en lugar de analizar datos. En los foros se repite la misma frustración: scripts caseros que "funcionaban el mes pasado" y que ahora necesitan parches constantes.
Así se comparan los tres enfoques principales:
| Criterio | Python DIY (BS4/Selenium) | API de scraping de pago | Thunderbit (sin código) |
|---|---|---|---|
| Tiempo de configuración | 1–3 horas | 30 min (clave API) | 2 minutos |
| Coste | Gratis (+ coste de proxies) | 50–200 USD/mes o más | Plan gratuito disponible |
| Gestión del muro de login | Gestión manual de cookies | Normalmente incluido | Gestionado automáticamente |
| Mantenimiento | Alto (se rompen selectores) | Bajo (el proveedor mantiene) | Cero (la IA se adapta) |
| Paginación | Requiere código personalizado | Integrada | Integrada |
| Soporte multipaís | Sesiones separadas por dominio | Normalmente compatible | Basado en navegador = tu locale |
| Análisis de sentimiento | Debes añadir tu propio código | A veces incluido | Exporta a Sheets y analiza donde quieras |
| Ideal para | Aprender, control total | Pipelines de producción y escala | Extracciones rápidas, equipos no técnicos |
Python te da control total y, de verdad, es la mejor forma de aprender cómo funciona el web scraping por dentro. Las APIs de pago (ScrapingBee, Oxylabs, Bright Data) tienen sentido para pipelines de producción donde la disponibilidad importa más que el coste. Y para equipos que necesitan datos de reseñas sin la carga de desarrollo —operaciones ecommerce que revisan semanalmente productos de la competencia, equipos de marketing que extraen lenguaje de clientes para copys— existe una tercera vía.
Cómo extraer reseñas de Amazon con Thunderbit (sin código, sin mantenimiento)
Creamos Thunderbit para resolver exactamente estos casos en los que mantener un scraper en Python se siente excesivo. El flujo es este:
- Instala la extensión de Chrome de Thunderbit
- Abre la página de reseñas del producto de Amazon en tu navegador (ya has iniciado sesión, así que el muro de login no supone problema)
- Haz clic en "AI Suggest Fields" — Thunderbit lee la página y sugiere columnas como Autor, Valoración, Título, Texto de la reseña, Fecha y Compra verificada
- Haz clic en "Scrape" — los datos se extraen al instante, con paginación integrada
- Exporta a Excel, Google Sheets, Airtable o Notion
La gran ventaja es que la IA de Thunderbit vuelve a leer la estructura de la página cada vez. Sin selectores CSS que mantener, sin gestión de cookies, sin código anti-bot. Cuando Amazon cambia el HTML, la IA se adapta. Para lectores que quieren acceso programático sin hacerlo todo a mano, Thunderbit también ofrece una Extract API — extracción estructurada de datos vía API con detección de campos asistida por IA, sin mantenimiento de selectores.
Para profundizar en los datos de Amazon, consulta nuestras guías sobre cómo extraer productos y reseñas de Amazon y cómo extraer y analizar datos de ventas de Amazon.
Consejos para extraer reseñas de Amazon a gran escala con Python
Si vas a extraer reseñas de muchos ASIN, estas prácticas te ahorrarán dolores de cabeza:
- Agrupa tus ASIN con pausas entre productos, no solo entre páginas. Yo uso descansos de 10–15 segundos entre ASIN.
- Deduplica de forma agresiva. Al combinar varios filtros por estrellas y órdenes de ordenación, obtendrás reseñas solapadas. Usa un conjunto de tuplas
(title, author, date)como clave de deduplicación. - Registra los fallos. Haz seguimiento de qué combinaciones de ASIN + página + filtro fallaron para reintentarlas sin volver a extraer todo.
- Guarda en una base de datos para proyectos grandes. Una base de datos SQLite simple escala mucho mejor que archivos CSV cada vez más grandes:
import sqlite3
conn = sqlite3.connect("reviews.db")
df.to_sql("reviews", conn, if_exists="append", index=False)
- Programa extracciones recurrentes. Para monitorización continua, configura un cron job o usa la función Scheduled Scraper de Thunderbit: describes la URL y la frecuencia, y se encarga del resto sin necesidad de servidor.
Para más enfoques, nuestros artículos sobre las mejores herramientas automatizadas de web scraping y cómo extraer datos de sitios web a Excel cubren opciones adicionales.
Una nota rápida sobre aspectos legales y éticos
Los Términos de uso de Amazon prohíben explícitamente "el uso de cualquier robot, spider, scraper u otro medio automatizado para acceder a los servicios de Amazon". Dicho esto, la jurisprudencia reciente en EE. UU. ha sido favorable a los scrapers de datos públicos. En Meta Platforms v. Bright Data (enero de 2024), un tribunal federal dictaminó que extraer datos accesibles públicamente no viola los términos de servicio cuando el scraper no es un "usuario" autenticado.
El matiz importante: extraer datos detrás de un inicio de sesión (que es lo que cubre este tutorial) te lleva al terreno del derecho contractual, ya que aceptaste los Términos de Amazon al crear tu cuenta. Extraer reseñas destacadas visibles públicamente tiene menos riesgo legal que hacerlo detrás del muro de login.
Guías prácticas: no redistribuyas comercialmente los datos extraídos, no recopiles datos personales de usuarios más allá de lo que se muestra públicamente, respeta robots.txt y consulta a un asesor legal para usos a gran escala o comerciales. Esto no es asesoramiento legal. Para más información sobre el panorama jurídico, consulta nuestro resumen sobre las implicaciones legales del web scraping.
Conclusión: extrae reseñas de Amazon con Python o evita el código por completo
Resumen rápido de lo que hemos visto en esta guía:
- El muro de inicio de sesión es real, pero se puede resolver con autenticación basada en cookies: copia 7 cookies desde tu navegador e inyéctalas en una
requests.Session() - Usa selectores
data-hook, no clases CSS, para una extracción que no se rompa cada pocas semanas - Combina filtros por estrellas y órdenes de ordenación para superar el límite de paginación de 10 páginas y acceder a 500+ reseñas por producto
- Añade análisis de sentimiento con TextBlob para una base rápida o con Hugging Face Transformers para mayor precisión en producción
- Mantén defensas anti-bot: limitación de velocidad, rotación de User-Agent, backoff exponencial y proxies residenciales para escalar
Python te da control total y es la mejor forma de entender qué pasa por debajo. Pero si tu caso de uso es "necesito datos de reseñas de la competencia en una hoja de cálculo para el viernes" y no "quiero construir un pipeline de datos en producción", quizá el coste de mantenimiento de un scraper personalizado no compense.
Thunderbit gestiona autenticación, selectores, paginación y exportación con unos pocos clics: prueba el plan gratuito y comprueba si encaja con tu flujo de trabajo. A medida que Amazon sigue endureciendo sus medidas anti-bot, las herramientas impulsadas por IA que se adaptan en tiempo real dejarán de ser un extra interesante para convertirse en una necesidad.
También puedes explorar nuestro canal de YouTube de Thunderbit para ver tutoriales en vídeo sobre flujos de scraping.
FAQs
1. ¿Se pueden extraer reseñas de Amazon sin iniciar sesión?
Sí, pero solo las unas 8 "reseñas destacadas" que aparecen en la página de detalles del producto (/dp/{ASIN}/). Las páginas completas de reseñas con ordenación, filtrado y paginación requieren autenticación desde finales de 2024. Para la mayoría de casos de uso empresarial, tendrás que gestionar el muro de login.
2. ¿Es legal extraer reseñas de Amazon?
Los Términos de Servicio de Amazon prohíben el scraping automatizado. Sin embargo, la jurisprudencia reciente en EE. UU. (Meta v. Bright Data, 2024; hiQ v. LinkedIn) respalda la extracción de datos accesibles públicamente. Extraer datos detrás de un inicio de sesión implica un mayor riesgo legal porque aceptaste los Términos de Amazon. Consulta a un abogado para uso comercial.
3. ¿Cuántas reseñas de Amazon puedo extraer por producto?
Amazon limita las páginas de reseñas a 10 por cada combinación de ordenación y filtro por estrellas. Usando los 5 filtros de estrellas × 2 órdenes, puedes acceder a un máximo de 100 páginas (aproximadamente 1.000 reseñas) por producto. Con filtros por palabra clave, el techo teórico es bastante más alto, aunque con bastante duplicación.
4. ¿Cuál es la mejor biblioteca de Python para extraer reseñas de Amazon?
requests + BeautifulSoup para parsear HTML estático es la combinación más común y fiable. Selenium es útil cuando se requiere renderizado JavaScript. Si prefieres una alternativa sin código que gestione automáticamente muros de login y paginación, prueba Thunderbit.
5. ¿Cómo evito que me bloqueen al extraer datos de Amazon?
Rota cadenas de User-Agent a partir de un pool de más de 10 navegadores reales, añade retrasos aleatorios de 2–5 segundos entre solicitudes, implementa backoff exponencial ante errores 503/429, usa proxies residenciales para escalar (las IPs de centros de datos suelen estar bloqueadas de antemano) y mantén cookies de sesión coherentes entre solicitudes. Para un enfoque sin mantenimiento, Thunderbit gestiona automáticamente las defensas anti-bot a través de tu sesión del navegador.
Más información
