Cómo extraigo reseñas de Amazon con Python (saltándome la barrera de inicio de sesión)

Mi scraper de reseñas de Amazon funcionó de maravilla durante seis semanas; luego, una mañana, me devolvió 200 OK y una página totalmente en blanco. Sin errores, sin CAPTCHA, solo HTML vacío donde antes había cientos de reseñas.

Si esto te suena, no eres el único. A finales de 2025, Amazon empezó a bloquear el acceso a sus páginas completas de reseñas detrás de una barrera de inicio de sesión, y muchísimos scripts de scraping en Python dejaron de funcionar de un día para otro. He pasado los últimos meses en metido en este problema desde dos frentes: construyendo nuestro scraper con IA y manteniendo también mi propio flujo de reseñas en Python. Por eso pensé que ya tocaba escribir la guía que me habría gustado tener cuando mi script dejó de responder. En este artículo te enseño el enfoque que sí funciona: autenticación basada en cookies, selectores estables que sobreviven a la ofuscación CSS de Amazon, trucos para saltarte el límite de paginación de 10 páginas, defensas anti-bot y, como extra, una sección de análisis de sentimiento para convertir texto bruto en información útil para el negocio. Y si a mitad de camino piensas: "prefiero no mantener todo este código", te mostraré cómo hace lo mismo en unos dos minutos y sin Python.

¿Qué es el scraping de reseñas de Amazon y por qué importa?

El scraping de reseñas de Amazon consiste en extraer de forma programática datos de valoraciones y opiniones de clientes — estrellas, texto de la reseña, nombre del autor, fecha, distintivo de compra verificada — desde las páginas de productos de Amazon. Como Amazon (y nunca lo volvió a añadir), el web scraping es la única vía programática para acceder a esos datos.

Los números no mienten. , y . Mostrar solo 5 reseñas en una página de producto puede . Las empresas que analizan de forma sistemática el sentimiento de las reseñas ven . Esto no va de ciencia de datos abstracta: es inteligencia competitiva, señales para mejorar productos y lenguaje de marketing, todo en texto plano dentro de los servidores de Amazon.

Por qué extraer reseñas de Amazon con Python

Python sigue siendo el lenguaje favorito para este trabajo. Es el , y su ecosistema — requests, BeautifulSoup, pandas, Scrapy — hace que el scraping web sea accesible incluso para quienes no se dedican a programar a tiempo completo.

Distintos equipos aprovechan estos datos de formas distintas:

Una marca de utensilios de cocina , reformuló el producto y recuperó el puesto número 1 en Best Seller en 60 días. Una empresa de pulseras de actividad , identificó un problema de alergia al látex, lanzó una versión hipoalergénica y redujo las devoluciones en un 40%. Ese es el tipo de retorno que justifica el esfuerzo técnico.

Barrera de inicio de sesión: por qué tu scraper de reseñas de Amazon dejó de funcionar

El 14 de noviembre de 2024, . El cambio quedó confirmado tanto en como en . Si visitas /product-reviews/{ASIN}/ en una ventana de incógnito, te redirigirá a una página de inicio de sesión en vez de mostrarte las reseñas.

Los síntomas son sutiles: tu script recibe una respuesta 200 OK, pero el cuerpo HTML contiene un formulario de login (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 anti-bot y de cumplimiento regional. La aplicación es inconsistente: a veces una ventana de navegador nueva carga algunas reseñas antes de que aparezca la barrera, sobre todo en la primera página, pero para cualquier scraper a escala debes asumir que la barrera está siempre activa.

Los distintos dominios regionales de Amazon (.de, .co.uk, .co.jp) aplican la barrera de forma independiente. Como dijo un usuario en un foro: "se requiere un login para cada país". Tus cookies de .com no servirán en .co.uk.

Reseñas destacadas vs. reseñas completas: qué puedes seguir viendo sin iniciar sesión

Las páginas de producto de Amazon (/dp/{ASIN}/) todavía muestran aproximadamente sin autenticación. Amazon las selecciona con su algoritmo 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 estrellas y paginación a lo largo de cientos de reseñas — sí requieren inicio de sesión.

Si solo necesitas unas pocas reseñas para una lectura rápida, extrae las del producto. Si necesitas cientos o miles, tendrás que gestionar la autenticación.

Qué necesitas antes de empezar: configuración de Python y librerías

Antes de escribir código, aquí va la preparación:

• Nivel: Intermedio (comodidad con Python y conocimientos básicos de HTML)
• Tiempo estimado: ~45 minutos para el flujo completo; ~10 minutos para una extracción básica
• Necesitarás: Python 3.8+, navegador Chrome y una cuenta válida de Amazon

Instala las librerías principales:

1pip install requests beautifulsoup4 lxml pandas textblob

Opcional (para análisis de sentimiento avanzado):

1pip 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: saltar la barrera de login con autenticación basada en cookies

El método más fiable es iniciar sesión en Amazon en tu navegador, copiar tus cookies de sesión e inyectarlas en requests.Session() de Python. Así evitas disparar CAPTCHAs y la 2FA por SMS que suelen complicar la automatización con Selenium.

Necesitas estas siete cookies:

Cómo extraer cookies desde Chrome DevTools

1. Inicia sesión en amazon.com en Chrome
2. Abre DevTools (F12 o clic derecho → Inspeccionar)
3. Ve a Application → Storage → Cookies → https://www.amazon.com
4. Busca cada cookie de la tabla y copia su valor
5. Formátalas como una cadena separada por punto y coma para Python

Configura tu sesión así:

1import requests
2session = requests.Session()
3# Pega aquí los valores de tus cookies
4cookies = {
5    "session-id": "YOUR_SESSION_ID",
6    "session-id-time": "YOUR_SESSION_ID_TIME",
7    "session-token": "YOUR_SESSION_TOKEN",
8    "ubid-main": "YOUR_UBID_MAIN",
9    "at-main": "YOUR_AT_MAIN",
10    "sess-at-main": "YOUR_SESS_AT_MAIN",
11    "x-main": "YOUR_X_MAIN",
12}
13headers = {
14    "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",
15    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
16    "Accept-Language": "en-US,en;q=0.5",
17}
18session.cookies.update(cookies)
19session.headers.update(headers)

Importante: reutiliza el mismo objeto session en todas tus solicitudes. Así mantienes las cookies coherentes y simulas una sesión real del navegador. Normalmente las cookies duran de días a semanas bajo carga de scraping, pero si vuelves a ver redirecciones al login, actualízalas desde el navegador.

En marketplaces que no son .com, los nombres de las 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 analizar el HTML de reseñas con BeautifulSoup

La URL de reseñas de Amazon sigue este patrón:

1https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1

La función principal:

1from bs4 import BeautifulSoup
2import time, random
3def get_soup(session, url):
4    time.sleep(random.uniform(2, 5))  # Pausa prudente
5    response = session.get(url, timeout=15)
6    # Detectar barrera de login
7    if "ap_email" in response.text or "Amazon Sign-In" in response.text:
8        raise Exception("Se detectó la barrera de login — actualiza tus cookies")
9    if response.status_code != 200:
10        raise Exception(f"HTTP {response.status_code}")
11    return BeautifulSoup(response.text, "lxml")

Un pequeño truco que ayuda: antes de entrar a la página de reseñas, visita primero la página del producto. Eso genera un patrón de navegación más natural en tu sesión.

1# Visita primero la página del producto (simula navegación real)
2product_url = f"https://www.amazon.com/dp/{asin}"
3session.get(product_url, timeout=15)
4time.sleep(random.uniform(1, 3))
5# Luego accede a la página de reseñas
6reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
7soup = get_soup(session, reviews_url)

Paso 3: usa selectores estables para extraer los datos de reseñas (deja de depender de las clases CSS)

Aquí es donde fallan la mayoría de 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 seguía un patrón 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 aleatorizan.

El código de extracción usando selectores data-hook:

1import re
2def extract_reviews(soup):
3    reviews = []
4    review_divs = soup.select('[data-hook="review"]')
5    for div in review_divs:
6        # Valoración por estrellas
7        rating_el = div.select_one('[data-hook="review-star-rating"]')
8        rating = None
9        if rating_el:
10            rating_text = rating_el.get_text(strip=True)
11            match = re.search(r'(\d\.?\d?)', rating_text)
12            if match:
13                rating = float(match.group(1))
14        # Título
15        title_el = div.select_one('[data-hook="review-title"]')
16        title = title_el.get_text(strip=True) if title_el else ""
17        # Cuerpo
18        body_el = div.select_one('[data-hook="review-body"]')
19        body = body_el.get_text(strip=True) if body_el else ""
20        # Autor
21        author_el = div.select_one('span.a-profile-name')
22        author = author_el.get_text(strip=True) if author_el else ""
23        # Fecha y país
24        date_el = div.select_one('[data-hook="review-date"]')
25        date_text = date_el.get_text(strip=True) if date_el else ""
26        # Formato: "Reviewed in the United States on January 15, 2025"
27        country_match = re.search(r'Reviewed in (.+?) on', date_text)
28        date_match = re.search(r'on (.+)$', date_text)
29        country = country_match.group(1) if country_match else ""
30        date = date_match.group(1) if date_match else ""
31        # Compra verificada
32        verified_el = div.select_one('[data-hook="avp-badge"]')
33        verified = bool(verified_el)
34        reviews.append({
35            "author": author,
36            "rating": rating,
37            "title": title,
38            "content": body,
39            "date": date,
40            "country": country,
41            "verified": verified,
42        })
43    return reviews

He estado ejecutando este conjunto de selectores sobre varios ASIN durante meses, y los atributos data-hook no han cambiado ni una sola vez. Las clases CSS, en cambio, han cambiado al menos dos veces en ese periodo.

Paso 4: gestiona 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 duro de unas 100 reseñas por combinación de filtros. El botón "Next page" simplemente desaparece después de la página 10.

Bucle básico de paginación:

1all_reviews = []
2for page in range(1, 11):
3    url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
4    soup = get_soup(session, url)
5    page_reviews = extract_reviews(soup)
6    if not page_reviews:
7        break  # No hay más reseñas en esta página
8    all_reviews.extend(page_reviews)
9    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 dividir 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 una distribución desigual de estrellas, muchas veces te acercarás bastante al conjunto completo de reseñas.

1star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
2sort_orders = ["recent", "helpful"]
3all_reviews = []
4seen_titles = set()  # Deducción simple
5for star in star_filters:
6    for sort in sort_orders:
7        for page in range(1, 11):
8            url = (
9                f"https://www.amazon.com/product-reviews/{asin}"
10                f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
11            )
12            soup = get_soup(session, url)
13            page_reviews = extract_reviews(soup)
14            if not page_reviews:
15                break
16            for review in page_reviews:
17                # Eliminar duplicados por combinación título + autor
18                key = (review["title"], review["author"])
19                if key not in seen_titles:
20                    seen_titles.add(key)
21                    all_reviews.append(review)
22            print(f"[{star}/{sort}] Página {page}: {len(page_reviews)} reseñas")
23print(f"Total de reseñas únicas: {len(all_reviews)}")

Habrá solapamiento entre bloques, así que la deduplicación es clave. Yo uso una combinación de título de la reseña + nombre del autor como clave rápida; no es perfecta, pero detecta la gran mayoría de duplicados.

Paso 5: esquiva las defensas anti-bot (rota, reduce la velocidad, reintenta)

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.

Un envoltorio de reintentos listo para producción:

1import time, random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
4    "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",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
6    "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",
7    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
8]
9def scrape_with_retries(session, url, max_retries=3):
10    for attempt in range(max_retries):
11        try:
12            session.headers["User-Agent"] = random.choice(USER_AGENTS)
13            time.sleep(random.uniform(2, 5))
14            response = session.get(url, timeout=15)
15            # Detectar bloqueos
16            if "validateCaptcha" in response.url or "Robot Check" in response.text:
17                wait = (2 ** attempt) * 5
18                print(f"CAPTCHA detectado. Esperando {wait}s...")
19                time.sleep(wait)
20                continue
21            if response.status_code in (429, 503):
22                wait = (2 ** attempt) * 2
23                print(f"Límite de tasa detectado ({response.status_code}). Esperando {wait}s...")
24                time.sleep(wait)
25                continue
26            if "ap_email" in response.text:
27                raise Exception("Barrera de login — las cookies han expirado")
28            return BeautifulSoup(response.text, "lxml")
29        except Exception as e:
30            if attempt == max_retries - 1:
31                raise
32            print(f"El intento {attempt + 1} falló: {e}")
33    return None

Una nota sobre proxies: Amazon (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 al mes o más, según el volumen. Para proyectos pequeños (menos de 100 solicitudes al día), normalmente basta con una buena limitación de ritmo desde tu IP doméstica.

Amazon también inspecciona las huellas TLS. La librería requests de Python tiene un . Para scrapers de producción, considera curl_cffi, que imita las pilas TLS de navegadores reales. Para scraping a escala tutorial (unas pocas centenas de páginas), requests con buenos headers suele ser suficiente.

Paso 6: exporta tus reseñas de Amazon a CSV o Excel

Una vez que hayas recopilado las reseñas, pasarlas a un formato útil es muy sencillo con pandas:

1import pandas as pd
2df = pd.DataFrame(all_reviews)
3df.to_csv("amazon_reviews.csv", index=False)
4print(f"Exportadas {len(df)} reseñas a amazon_reviews.csv")

Salida de ejemplo:

Para exportar a Excel: df.to_excel("amazon_reviews.xlsx", index=False) (requiere openpyxl).

Para Google Sheets, la librería gspread funciona, pero requiere : 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 propio scraping, no vas desencaminado. (Este es uno de esos momentos en los que una herramienta como , que exporta a Google Sheets con un clic, empieza a resultar muy atractiva.)

Extra: añade análisis de sentimiento a tus reseñas en 5 líneas de Python

La mayoría de tutoriales de scraping se quedan en la exportación CSV. Pero puntuar el sentimiento es lo que convierte los datos en decisiones de negocio.

La base más rápida usa TextBlob:

1from textblob import TextBlob
2df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)

Eso te da una puntuación de polaridad entre -1.0 (muy negativa) y +1.0 (muy positiva) para cada reseña. Salida de ejemplo:

Las filas más interesantes son las que no cuadran: una reseña de 3 estrellas con texto positivo, o una de 5 estrellas con lenguaje negativo. Esas discrepancias suelen revelar opiniones matizadas que las estrellas por sí solas no muestran.

Para una precisión de nivel producción, la recomendación es Hugging Face Transformers. , y frente a herramientas léxicas. El modelo nlptown/bert-base-multilingual-uncased-sentiment incluso predice directamente puntuaciones de 1 a 5 estrellas:

1from transformers import pipeline
2clf = pipeline("sentiment-analysis",
3               model="nlptown/bert-base-multilingual-uncased-sentiment")
4df["predicted_stars"] = df["content"].apply(
5    lambda x: int(clf(str(x)[:512])[0]["label"][0])
6)

Las reseñas de Amazon siguen una : un gran pico en 5 estrellas, un pico más pequeño en 1 estrella y un valle en el medio. Eso significa que la media de estrellas suele ser un mal indicador de la calidad real del producto. Segmenta el grupo de 1 estrella y saca los temas recurrentes; normalmente ahí aparece un único fallo que sí se puede corregir.

El trade-off honesto: Python hecho por ti vs. APIs de scraping de pago vs. Thunderbit

He mantenido scrapers en Python para Amazon y, siendo sincero, se rompen. Los selectores cambian, las cookies expiran, Amazon lanza una nueva capa de detección de bots y, de repente, tu sábado por la mañana se convierte en depurar un scraper en vez de analizar datos. Los usuarios de foros cuentan la misma frustración: scripts caseros que "funcionaban el mes pasado" ahora necesitan parches constantes.

Así se comparan las tres vías principales:

Python te da control total y, de verdad, es la mejor forma de entender cómo funciona el 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 vigilan productos de la competencia cada semana, equipos de marketing que buscan lenguaje del cliente para anuncios — existe una tercera opción.

Cómo extraer reseñas de Amazon con Thunderbit (sin código, sin mantenimiento)

Creamos para resolver exactamente los casos en los que mantener un scraper en Python es demasiado para lo que necesitas. El flujo es este:

1. Instala la
2. Ve a la página de reseñas del producto de Amazon en tu navegador (ya has iniciado sesión, así que la barrera de login no es problema)
3. Haz clic en "AI Suggest Fields" — Thunderbit lee la página y propone columnas como Autor, Valoración, Título, Texto de la reseña, Fecha y Compra verificada
4. Haz clic en "Scrape" — los datos se extraen al instante, con paginación integrada
5. Exporta a Excel, Google Sheets, Airtable o Notion

La gran ventaja es que la IA de Thunderbit relee 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 su HTML, la IA se adapta. Para quienes quieren acceso programático sin construirlo todo a mano, Thunderbit también ofrece una — extracción estructurada de datos vía API con detección de campos asistida por IA, sin mantenimiento de selectores.

Para profundizar en datos de Amazon, consulta nuestras guías sobre y .

Consejos para extraer reseñas de Amazon a gran escala con Python

Si vas a extraer reseñas de muchos ASIN, unas cuantas prácticas te ahorrarán dolores de cabeza:

• Procesa los ASIN por lotes 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 de estrellas y órdenes de clasificación, obtendrás reseñas solapadas. Usa un conjunto de tuplas (title, author, date) como clave de deduplicación.
• Registra fallos. Lleva un control 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 SQLite simple escala mucho mejor que dejar crecer archivos CSV:

1import sqlite3
2conn = sqlite3.connect("reviews.db")
3df.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 servidor.

Para más enfoques, nuestros artículos sobre y cubren opciones adicionales.

Una nota rápida sobre aspectos legales y éticos

Las de Amazon prohíben explícitamente "el uso de cualquier robot, spider, scraper u otro medio automatizado para acceder a Amazon Services". Dicho esto, la jurisprudencia reciente en EE. UU. ha sido favorable al scraping de datos públicos. En , un tribunal federal dictaminó que extraer datos públicamente accesibles no viola los términos del servicio cuando el scraper no actúa como un "usuario" con sesión iniciada.

El matiz importante: hacer scraping detrás de un login — que es justo lo que cubre este tutorial — te mete en el terreno del derecho contractual, ya que aceptaste los Términos de Amazon al crear tu cuenta. Extraer solo las reseñas destacadas visibles públicamente implica menos riesgo legal que hacerlo detrás de la barrera de login.

Pautas prácticas: no redistribuyas comercialmente los datos extraídos, no recojas datos personales de usuarios más allá de lo que se muestra públicamente, respeta robots.txt y consulta a un abogado para usos comerciales o a gran escala. Esto no es asesoramiento legal. Para más información sobre el panorama legal, consulta nuestro resumen sobre .

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:

• La barrera de login existe, pero se puede resolver con autenticación basada en cookies: copia 7 cookies desde tu navegador e inyéctalas en requests.Session()
• Usa selectores data-hook, no clases CSS, para que la extracción no se rompa cada pocas semanas
• Combina filtros por estrellas y órdenes de clasificación para superar el límite 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 ritmo, rotación de User-Agent, backoff exponencial y proxies residenciales para escalar

Python te da control total y es la mejor forma de entender lo que ocurre bajo el capó. Pero si tu caso de uso es "necesito las reseñas de la competencia en una hoja de cálculo para el viernes" y no "quiero construir una tubería de datos de producción", la carga de mantenimiento de un scraper personalizado puede no compensar.

gestiona autenticación, selectores, paginación y exportación con unos pocos clics: prueba el y mira si encaja con tu flujo de trabajo. A medida que Amazon sigue endureciendo las medidas anti-bot, las herramientas con IA que se adaptan en tiempo real van a pasar de ser un extra cómodo a convertirse en una necesidad.

También puedes explorar nuestro para ver tutoriales en vídeo sobre flujos de scraping.

Preguntas frecuentes

1. ¿Se pueden extraer reseñas de Amazon sin iniciar sesión?

Sí, pero solo las aproximadamente 8 "reseñas destacadas" que aparecen en la página de detalle del producto (/dp/{ASIN}/). Las páginas completas de reseñas con ordenación, filtros y paginación requieren autenticación desde finales de 2024. Para la mayoría de casos de negocio, tendrás que gestionar la barrera 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 públicamente accesibles. Hacer scraping detrás de un login implica mayor riesgo legal, ya que aceptaste los Términos de Amazon. Consulta con un abogado si el uso es comercial.

3. ¿Cuántas reseñas de Amazon puedo extraer por producto?

Amazon limita las páginas de reseñas a 10 por combinación de ordenación y filtro por estrellas. Usando los 5 filtros de estrellas × 2 órdenes, puedes acceder hasta a 100 páginas (aproximadamente 1.000 reseñas) por producto. Con filtros por palabra clave, el techo teórico es mucho mayor, aunque con bastante duplicación.

4. ¿Cuál es la mejor librería de Python para extraer reseñas de Amazon?

requests + BeautifulSoup para parsear HTML estático es la combinación más habitual y fiable. Selenium es útil cuando necesitas renderizado JavaScript. Para una alternativa sin código que gestione automáticamente la barrera de login y la paginación, prueba .

5. ¿Cómo evito que me bloqueen al extraer reseñas de Amazon?

Rota cadenas de User-Agent de un grupo de 10+ navegadores reales, añade retrasos aleatorios de 2 a 5 segundos entre solicitudes, implementa backoff exponencial en errores 503/429, usa proxies residenciales para escalar (las IP 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