Extractor de datos web de Amazon con Node.JS - Tutorial de JavaScript 2025

Amazon es una plataforma líder mundial de comercio electrónico con valiosos datos de productos para la investigación de mercado y el monitoreo de precios. Usando JavaScript y Node.js con Playwright, podemos construir un web scraper en JavaScript para extraer estos datos, pero desafíos como el renderizado de JavaScript, la detección anti-bot y los CAPTCHA dificultan el raspado manual.

La API de raspado de Amazon de Scrapeless ofrece una solución más rápida y confiable al manejar CAPTCHA, proxies y desbloqueo de sitios web, asegurando datos precisos en tiempo real sin detección. Este tutorial cubrirá ambos enfoques, mostrando por qué Scrapeless es la mejor opción para un raspado eficiente de datos de Amazon. 🚀

Desafíos en el raspado de Amazon

El raspado de Amazon presenta varios desafíos debido a sus fuertes protecciones anti-bot:

• Renderizado de JavaScript: Amazon depende en gran medida de JavaScript, lo que dificulta la extracción de datos con solicitudes HTTP simples. Se requiere un scraper de JavaScript que use Playwright o herramientas similares para renderizar contenido dinámico.
• Protección CAPTCHA: Los desafíos frecuentes de CAPTCHA interrumpen el raspado y requieren mecanismos de resolución para continuar con la extracción de datos.
• Bloqueo de IP y límites de velocidad: Amazon detecta y bloquea las solicitudes repetidas de la misma IP, lo que hace necesario rotar los proxies u otras técnicas de evasión.
• Cambios frecuentes en el sitio web: Amazon actualiza la estructura de su sitio web con regularidad, lo que puede romper los scripts de raspado y requerir un mantenimiento constante.

¿Cómo construir tu scraper de JavaScript con Node.js?

En el siguiente ejemplo, usaremos JavaScript para raspar Amazon y almacenar los datos extraídos en un archivo JSON local.

Preparación para el raspado

Necesitamos configurar las herramientas necesarias del web scraper de Node.js al principio:

En este artículo, usaré Playwright, un proyecto de código abierto muy activo con numerosos colaboradores. Desarrollado por Microsoft, admite múltiples navegadores (Chromium, Firefox y WebKit) y múltiples lenguajes de programación (Node.js, Python, .NET y Java), lo que lo convierte en uno de los frameworks de raspado de JavaScript más populares en la actualidad.

Aquí, asegúrate de que tu versión de Node.js sea 18 o superior, luego ejecuta el siguiente script para instalar Playwright:

# pnpm
pnpm create playwright
# yarn
yarn create playwright
# npm
npm init playwright@latest

¿Frustrado por el bloqueo web y la creación de proyectos que dan dolor de cabeza?
Únete a Nuestra Comunidad y obtén la solución efectiva con ¡Prueba gratuita!

Paso 1. Inspecciona la página objetivo

Antes de raspar, intenta visitar https://www.amazon.com/. Si es la primera vez que accedes al sitio, es posible que encuentres un CAPTCHA.

Pero no te preocupes, no necesitamos pasar por la molestia de encontrar una herramienta para resolver CAPTCHA. En su lugar, simplemente accede al dominio de Amazon específico de tu región o la ubicación de tu proxy, y no activarás un CAPTCHA.

Por ejemplo, visitemos https://www.amazon.co.uk/, el dominio de Amazon del Reino Unido. Verás que la página se carga sin problemas. Ahora, intenta ingresar la palabra clave del producto que desees en la barra de búsqueda superior o accede directamente a los resultados de búsqueda a través de una URL, como:

https://www.amazon.co.uk/s?k=jacket

En la URL, el valor después de /s?k= representa la palabra clave del producto. Al acceder a la URL anterior, verás productos relacionados con camisas en Amazon.

Ahora, abre las Herramientas para desarrolladores (F12) para inspeccionar la estructura HTML de la página. Usa el cursor para resaltar los elementos e identificar los datos que necesitaremos raspar más tarde.

Paso 2. Escribiendo el script

Primero, agreguemos un fragmento de código inicial en la parte superior del script. El siguiente código toma el primer argumento del script como la palabra clave del producto de Amazon, que se utilizará para raspar más tarde:

const productName = process.argv.slice(2);

if (productName.length !== 1) {console.error('¡Falta el argumento CLI del nombre del producto!');
  process.exit(2);
}

A continuación, necesitamos:

• Importar Playwright para interactuar con el navegador.
• Navegar a la página de resultados de búsqueda de Amazon.
• Agregar una captura de pantalla para verificar el acceso exitoso.

import playwright from "playwright";

const browser = await playwright.chromium.launch()

const page = await browser.newPage();

await page.goto(`https://www.amazon.co.uk/s?k=${productName}`);

// Agregar una captura de pantalla para la depuración
await page.screenshot({ path: 'amazon_page.png' })

Ahora, usaremos page.$$ para obtener todos los contenedores de productos, recorrerlos y extraer los datos relevantes. Estos datos se almacenan luego en la matriz productDataList y se imprimen:

// Obtener todos los contenedores de resultados de búsqueda
const productContainers = await page.$$('div[data-component-type="s-search-result"]')

const productDataList = []

// Extraer detalles del producto: título, calificación, URL de la imagen y precio
for (const product of productContainers) {

  async function safeEval(selector, evalFn) {
    try {
      return await product.$eval(selector, evalFn);
    } catch (e) {
      return null;
    }
  }

  const title = await safeEval('.s-title-instructions-style > h2 > a > span', node => node.textContent)
  const rate = await safeEval('a > i.a-icon.a-icon-star-small > span', node => node.textContent)
  const img = await safeEval('span[data-component-type="s-product-image"] img', node => node.getAttribute('src'))
  const price = await safeEval('div[data-cy="price-recipe"] .a-offscreen', node => node.textContent)

  productDataList.push({ title, rate, img, price })
}

console.log('amazon_product_data_list :', productDataList);

await browser.close();

Ejecuta el script usando:

node amazon.js jacket

Si tiene éxito, la consola imprimirá los datos del producto extraídos.

Paso 3. Guardar los datos raspados como un archivo JSON

Simplemente imprimir datos en la consola no es suficiente para un análisis adecuado. Guardemos los datos extraídos en un archivo JSON usando el módulo fs de Node.js:

import fs from 'fs'

function saveObjectToJson(obj, filename) {
  const jsonString = JSON.stringify(obj, null, 2)
  fs.writeFile(filename, jsonString, 'utf8', (err) => {
    err ? console.error(err) : console.log(`Archivo guardado correctamente: ${filename}`);
  });
}

saveObjectToJson(productDataList, 'amazon_product_data.json')

Bien, veamos el script completo:

import playwright from "playwright";
import fs from 'fs'

const productName = process.argv.slice(2);

if (productName.length !== 1) {
  console.error('¡Falta el argumento CLI del nombre del producto!');
  process.exit(2);
}

const browser = await playwright.chromium.launch()

const page = await browser.newPage();

await page.goto(`https://www.amazon.co.uk/s?k=${productName}`);

// Agregar una captura de pantalla para la depuración
await page.screenshot({ path: 'amazon_page.png' })

// Obtener todos los contenedores de resultados de búsqueda
const productContainers = await page.$$('div[data-component-type="s-search-result"]')

const productDataList = []

// Extraer detalles del producto: título, calificación, URL de la imagen y precio
for (const product of productContainers) {

  async function safeEval(selector, evalFn) {
    try {
      return await product.$eval(selector, evalFn);
    } catch (e) {
      return null;
    }
  }

  const title = await safeEval('.s-title-instructions-style  > a > h2 > span', node => node.textContent)
  const rate = await safeEval('a > i.a-icon.a-icon-star-small > span', node => node.textContent)
  const img = await safeEval('span[data-component-type="s-product-image"] img', node => node.getAttribute('src'))
  const price = await safeEval('div[data-cy="price-recipe"] .a-offscreen', node => node.textContent)

  productDataList.push({ title, rate, img, price })
}

console.log('amazon_product_data_list :', productDataList);

function saveObjectToJson(obj, filename) {
  const jsonString = JSON.stringify(obj, null, 2)
  fs.writeFile(filename, jsonString, 'utf8', (err) => {
    err ? console.error(err) : console.log(`Archivo guardado correctamente: ${filename}`);
  });
}

saveObjectToJson(productDataList, 'amazon_product_data.json')

await browser.close();

Ahora, después de ejecutar el script, los datos no solo se imprimirán en la consola, sino que también se guardarán como un archivo JSON (amazon_product_data.json).

Evita ser bloqueado mientras raspas Amazon

Raspar datos de Amazon puede ser un desafío debido a sus estrictas medidas anti-bot, pero el uso de Desbloqueador web de Scrapeless ayuda a evitar eficazmente estas restricciones.

Amazon emplea técnicas de detección de bots como limitación de velocidad de IP, huellas digitales del navegador y verificación CAPTCHA para evitar el acceso automatizado. El Desbloqueador web de Scrapeless supera estos obstáculos rotando proxies residenciales, imitando el comportamiento de un usuario real y manejando el renderizado de contenido dinámico.

Al integrar Scrapeless con navegadores sin cabeza como Playwright o Playwright, los usuarios pueden raspar los datos del producto de Amazon sin ser bloqueados, asegurando un proceso de extracción de datos fluido y eficiente.

Mejores prácticas y consideraciones de raspado de JavaScript

Al construir un web scraper en JavaScript, es crucial optimizar la eficiencia, manejar el contenido dinámico y evitar los errores comunes. Aquí hay algunas mejores prácticas y consideraciones clave:

1. Manejo de páginas renderizadas con JavaScript
   Muchos sitios web modernos cargan contenido dinámicamente usando JavaScript. Las solicitudes HTTP tradicionales (como Axios o Fetch) no capturarán dicho contenido. En su lugar, usa navegadores sin cabeza como Playwright, Playwright o Selenium para renderizar y extraer datos de páginas con mucho JavaScript.
2. Gestión de concurrencia para un raspado más rápido
   Ejecutar raspadores secuencialmente puede ser lento. Implementa la concurrencia iniciando varias tareas de raspado paralelas para mejorar el rendimiento. Usa async/await con Promises y gestiona un sistema de colas para equilibrar la carga de raspado de manera eficiente.
3. Respetar robots.txt y las políticas del sitio web
   Antes de raspar, verifica el archivo robots.txt de un sitio web para determinar sus reglas de raspado. Ignorar estas reglas puede provocar bloqueos de IP o problemas legales. Además, considera usar la rotación del agente de usuario y la limitación de solicitudes para minimizar el impacto en el servidor de destino.
4. Evitar los firewalls de aplicaciones web (WAF)
   Los sitios web implementan WAF como Akamai, Cloudflare y PerimeterX para bloquear el tráfico automatizado. Técnicas como la persistencia de sesión, la evasión de huellas digitales del navegador y las herramientas de resolución de CAPTCHA pueden ayudar a mitigar la detección y el bloqueo.
5. Gestión y desduplicación eficientes de URL
   Asegúrate de que tu raspador no vuelva a visitar las mismas URL varias veces manteniendo un conjunto de URL visitadas. Implementa técnicas de canonicalización para normalizar las URL y evitar la recopilación de datos duplicados.
6. Manejo de paginación y desplazamiento infinito
   Los sitios web a menudo usan paginación o desplazamiento infinito para cargar contenido dinámicamente. Identifica la estructura de paginación (por ejemplo, ?page=2) o usa navegadores sin cabeza para simular el desplazamiento y extraer todo el contenido.
7. Optimización de la extracción y el almacenamiento de datos
   Después de extraer los datos, formatéalos correctamente y almacénalos de manera eficiente. Guarda los datos estructurados en JSON, CSV o bases de datos como MongoDB o PostgreSQL para un mejor procesamiento y análisis.
8. Rascado distribuido para raspado a gran escala
   Para tareas de raspado a gran escala, distribuye la carga de trabajo en varias máquinas o instancias en la nube usando marcos de raspado basados en colas o soluciones de navegador en la nube. Esto evita sobrecargar un solo sistema y mejora la tolerancia a fallos.

Usar la API de raspado de Scrapeless para una solución más rápida y confiable

Al integrar Scrapeless con navegadores sin cabeza como Playwright, los usuarios pueden construir un raspador en JavaScript para extraer datos de productos de Amazon sin ser bloqueados, asegurando un proceso de extracción de datos fluido y eficiente.

Características:

✅ Obtén acceso instantáneo a los datos más recientes con solo una llamada a la API.
✅ Más de 200 solicitudes concurrentes por segundo con más de 100 millones de solicitudes por mes.
✅ Cada solicitud tarda un promedio de 5 segundos, asegurando la recuperación de datos en tiempo real sin almacenamiento en caché.
✅ Admite reglas de raspado personalizadas para satisfacer diferentes necesidades
✅ Admite raspado multiplataforma, además de Amazon, también puede admitir otras plataformas de comercio electrónico: Shopee, Shein, etc.
✅ Paga solo por las búsquedas exitosas

¿Por qué elegir Scrapeless?

• Datos en tiempo real: Garantiza listados de productos actualizados y precisos.
• Desbloqueo de sitio web integrado: Omite automáticamente las restricciones y los CAPTCHA.
• Legalidad: Scrapeless proporciona una forma legal y compatible de acceder a los resultados de búsqueda.
• Fiabilidad: La API utiliza técnicas sofisticadas para evitar la detección, asegurando una recopilación de datos ininterrumpida.
• Facilidad de uso: Scrapeless ofrece una API simple que se integra fácilmente con Python, lo que la hace ideal para desarrolladores que necesitan acceso rápido a los datos de resultados de búsqueda.
• Personalizable: Puedes adaptar los resultados a tus necesidades, como especificar el tipo de contenido (por ejemplo, listados orgánicos, anuncios, etc.).

¿Es costosa la API de raspado de Scrapeless?

Scrapeless ofrece una plataforma de raspado web confiable y escalable a precios competitivos (frente a Zenrows y Apify), asegurando un excelente valor para sus usuarios:

• Navegador de raspado: Desde $0.09 por hora
• API de raspado: Desde $0.8 por 1000 URL
• Desbloqueador web: $0.20 por 1000 URL
• Resolutor de CAPTCHA: Desde $0.80 por 1000 URL
• Proxies: $2.80 por GB

Al suscribirte, puedes disfrutar de descuentos de hasta un 20% de descuento en cada servicio.

Cómo implementar la API de raspado de Amazon de Scrapeless

Si buscas extraer números ASIN de las páginas de productos de Amazon, Scrapeless proporciona una forma simple y efectiva de hacerlo. Al usar la API de raspado de Amazon de Scrapeless, puedes obtener fácilmente números ASIN junto con otros detalles clave del producto.

Paso 1. Inicia sesión en Scrapeless.

Paso 2. Haz clic en API de raspado > selecciona Amazon para ingresar a la página de raspado de Shopee.

Paso 3. Pega el enlace a la página del producto de Amazon que deseas rastrear en el cuadro de entrada. Y selecciona el tipo de datos que deseas rastrear.

En la página de la herramienta, puedes seleccionar el tipo de datos que deseas rastrear:

• Vendedor: Rastrea la información del vendedor, incluido el nombre del vendedor, la calificación, la información de contacto, etc.
• Producto: Rastrea los detalles del producto, como el título, el precio, la calificación, los comentarios, etc.
• Palabras clave: Rastrea las palabras clave relacionadas con el producto para ayudarte a analizar el SEO del producto y las tendencias del mercado.

Paso 4. Después de confirmar que el enlace de entrada y el tipo de datos seleccionados son correctos, haz clic en el botón "Iniciar raspado". El sistema comenzará a rastrear datos y mostrará los resultados rastreados en el panel del lado derecho de la página.

Paso 5. Una vez completado el rastreo, puedes ver los datos rastreados en el panel de la derecha. Los resultados se mostrarán en un formato claro para facilitar el análisis.

Si necesitas rastrear otros productos, haz clic en Continuar para ingresar un nuevo enlace de Amazon y repite los pasos anteriores.

También puedes integrar directamente nuestros códigos en tu proyecto:

Node.js

const https = require('https');

class Payload {
    constructor(actor, input) {
        this.actor = actor;
        this.input = input;
    }
}

function sendRequest() {
    const host = "api.scrapeless.com";
    const url = `https://${host}/api/v1/scraper/request`;
    const token = " "; // API Token

    const inputData = {
        action: "product",
        url: " " // Product URL
    };

    const payload = new Payload("scraper.amazon", inputData);
    const jsonPayload = JSON.stringify(payload);

    const options = {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'x-api-token': token
        }
    };

    const req = https.request(url, options, (res) => {
        let body = '';

        res.on('data', (chunk) => {
            body += chunk;
        });

        res.on('end', () => {
            console.log("body", body);
        });
    });

    req.on('error', (error) => {
        console.error('Error:', error);
    });

    req.write(jsonPayload);
    req.end();
}

sendRequest();

Python

import json
import requests

class Payload:
    def __init__(self, actor, input_data):
        self.actor = actor
        self.input = input_data

def send_request():
    host = "api.scrapeless.com"
    url = f"https://{host}/api/v1/scraper/request"
    token = " " ## API Token

    headers = {
        "x-api-token": token
    }

    input_data = {
        "action": "product",
        "url": " " ## Product URL
    }

    payload = Payload("scraper.amazon", input_data)

    json_payload = json.dumps(payload.__dict__)

    response = requests.post(url, headers=headers, data=json_payload)

    if response.status_code != 200:
        print("Error:", response.status_code, response.text)
        return

    print("body", response.text)

if __name__ == "__main__":
    send_request()

Golang

package main

import (
        "bytes"
        "encoding/json"
        "fmt"
        "io/ioutil"
        "net/http"
)

type Payload struct {
        Actor string         `json:"actor"`
        Input map[string]any `json:"input"`
}

func sendRequest() error {
        host := "api.scrapeless.com"
        url := fmt.Sprintf("https://%s/api/v1/scraper/request", host)
        token := " " // API Token
        
        headers := map[string]string{"x-api-token": token}
        
        inputData := map[string]any{
                "action": "product",
                "url":    " ", // Product URL
        }
        
        payload := Payload{
                Actor: "scraper.amazon",
                Input: inputData,
        }
        
        jsonPayload, err := json.Marshal(payload)
        if err != nil {
                return err
        }
        
        req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonPayload))
        if err != nil {
                return err
        }
        
        for key, value := range headers {
                req.Header.Set(key, value)
        }
        
        client := &http.Client{}
        resp, err := client.Do(req)
        if err != nil {
                return err
        }
        defer resp.Body.Close()
        
        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
                return err
        }
        fmt.Printf("body %s\n", string(body))
        
        return nil
}

func main() {
        err := sendRequest()
        if err != nil {
                fmt.Println("Error:", err)
                return
        }
}

Conclusión: La mejor manera de raspar Amazon en 2025

Construir un scraper de JavaScript con Node.js proporciona un control total sobre el proceso de raspado, pero presenta desafíos como el manejo de contenido dinámico, la resolución de CAPTCHA, la gestión de proxies y la prevención de la detección. Requiere un esfuerzo técnico significativo y mantenimiento continuo.

Para un raspado eficiente, a gran escala e indetectable, la API de Scrapeless es la mejor opción. ¡Elimina las complejidades de la detección de bots, haciendo que la extracción de datos sea sencilla y escalable!

🚀 Prueba la API de raspado de Amazon de Scrapeless hoy mismo para una experiencia de raspado rápida, confiable y sin preocupaciones.