Web Scraping con Bright Data's Scraping Browser en Apify

En esta entrada de blog, aprenderá:

Qué es Apify
Por qué usar Scraping Browser con Apify es una situación en la que todos ganan
Cómo integrar Bright Data’s Scraping Browser en un script Apify Python
Cómo utilizar los proxies de Bright Data en Apify

Sumerjámonos.

¿Qué es Apify?

Apify es una plataforma completa de raspado web y extracción de datos. Le permite crear y ejecutar herramientas personalizadas de web scraping -conocidas como Actores- enla nube. Estos actores automatizan tareas relacionadas con la recopilación, el procesamiento y la automatización de datos.

En Apify, puede monetizar sus scripts de scraping haciéndolos públicos y poniéndolos a disposición de otros usuarios. Tanto si planea utilizar su Actor de forma privada como hacerlo público, las soluciones de scraping de Bright Data le ayudarán a que su scraper sea más fiable y eficaz.

¿Por qué utilizar el navegador de Bright Data en Apify?

Para apreciar el valor del Scraping Browser de Bright Data, debe comprender qué es la herramienta y qué ofrece.

La mayor limitación de las herramientas de automatización de navegadores no son sus API, sino los navegadores que controlan. Scraping Browser es un navegador web de última generación diseñado específicamente para el scraping web. En particular, viene con las siguientes características clave:

Huellas digitales TLS fiables para evitar la detección
Escalabilidad ilimitada para la extracción de datos a gran escala
Rotación de IP integrada impulsada por una red proxy de 150 millones de IP
Reintentos automáticos para gestionar las solicitudes fallidas
Capacidad para resolver CAPTCHA

Scraping Browser es compatible con todos los principales marcos de automatización de navegadores, incluidos Playwright, Puppeteer y Selenium. Por lo tanto, no necesita aprender una nueva API ni instalar dependencias de terceros. Simplemente puede integrarlo directamente en su script de scraping de automatización del navegador existente.

Ahora, el uso de Scraping Browser con Apify aporta aún más ventajas, lo que se traduce en los siguientes beneficios:

Reducción de los costes en la nube: Los navegadores consumen recursos significativos, lo que conlleva un mayor uso de CPU y RAM. Scraping Browser, alojado en la nube con escalabilidad ilimitada garantizada, reduce los costes en la nube durante las ejecuciones de los actores en Apify. Dado que Apify cobra por el uso del servidor, incluso teniendo en cuenta las tarifas de Scraping Browser, esta configuración puede resultar en un ahorro de costes.
Herramienta anti-bot todo en uno: Scraping Browser aborda las prohibiciones de IP, los desafíos CAPTCHA, los problemas de huellas dactilares del navegador y otras barreras anti-scraping. Esto hace que su proceso de scraping sea más eficiente y menos propenso a interrupciones.
Integración de proxy incorporada: Scraping Browser incluye gestión de proxy, por lo que ya no tendrá que preocuparse de mantener y rotar manualmente los proxies.
Beneficios deApify: El uso de Scraping Browser en un actor de Apify en la nube (en lugar de un script genérico) ofrece beneficios adicionales, tales como
```
:Polylang placeholder do not modify
```

La integración de Bright Data + Apify no sólo simplifica su flujo de trabajo de scraping, sino que también mejora la fiabilidad. Además, reduce el tiempo y el esfuerzo necesarios para poner en línea su bot de raspado web.

Cómo integrar el Scraping Browser de Bright Data en Apify: Guía paso a paso

El sitio objetivo de esta sección será Amazon, una plataforma rica en información pero tristemente célebre por sus estrictas medidas anti-bot. Sin las herramientas adecuadas, es probable que te encuentres con el infame CAPTCHA de Amazon, que bloqueará tus intentos de scraping:

En esta sección, construiremos un Actor de scraping que aprovecha el Scraping Browser de Bright Data para extraer datos de una página genérica de búsqueda de productos de Amazon:

La página de búsqueda de productos de Amazon

Nota: El Actor será escrito en Python, pero recuerde que Apify también soporta JavaScript.

¡Siga los siguientes pasos para aprender a integrar las herramientas de scraping de Bright Data con Apify!

Requisitos previos

Para seguir este tutorial, debes cumplir los siguientes requisitos previos:

Python 3.8+ instalado localmente: Para desarrollar y construir el script Actor local.
Node.js instalado localmente: Para instalar el Apify CLI.
Una cuenta de Apify: Para desplegar el Actor local en la plataforma Apify.
Una cuenta de Bright Data: Para acceder al Scraping Browser.

Paso nº 1: Configuración del proyecto

La forma más fácil de configurar un nuevo proyecto Apify Actor es mediante el uso de la CLI Apify. En primer lugar, instálalo globalmente a través de Node.js con el siguiente comando:

npm install -g apify-cli

A continuación, crea un nuevo proyecto Apify ejecutando:

npx apify-cli create

Se le pedirá que responda a algunas preguntas. Responda de la siguiente manera:

✔ Name of your new Actor: amazon-scraper
✔ Choose the programming language of your new Actor: Python
✔ Choose a template for your new Actor. Detailed information about the template will be shown in the next step.
Playwright + Chrome

De esta forma, la CLI de Apify creará un nuevo Actor Python en la carpeta amazon-scraper utilizando la plantilla “Playwright + Chrome”. Si no estás familiarizado con esas herramientas, lee nuestra guía sobre web scraping de Playwright.

Nota: Una plantilla de Selenium o Puppeteer también funcionaría, ya que Scraping Browser de Bright Data se integra con cualquier herramienta de automatización de navegadores.

Su proyecto Apify Actor tendrá la siguiente estructura:

amazon-scraper
│── .dockerignore
│── .gitignore
│── README.md
│── requirements.txt
│
├── .venv/
│   └── ...
│
├── .actor/
│   │── actor.json
│   │── Dockerfile
│   └── input_schema.json
│
├── src/
│   │── main.py
│   │── __init__.py
│   │── __main__.py
│   └── py.typed
│
└── storage/
    └── ...

Cargue la carpeta amazon-scraper en su IDE de Python preferido, como Visual Studio Code con la extensión Python o PyCharm Community Edition.

Ahora, tenga en cuenta que para ejecutar el Actor localmente, los navegadores de Playwright deben estar instalados. Para ello, active primero la carpeta del entorno virtual (.venv) dentro del directorio de su proyecto. En Windows, ejecute:

.venv/Scripts/activate

De forma equivalente, en Linux/macOS, ejecute:

source .venv/bin/activate

A continuación, instale las dependencias necesarias de Playwright ejecutando:

playwright install --with-deps

¡Maravilloso! Ahora puede ejecutar su Actor localmente con:

apify run

¡Su proyecto Apify está ahora completamente configurado y listo para ser integrado con el Scraping Browser de Bright Data!

Paso 2: Conectarse a la página de destino

Si echa un vistazo a la URL de una página de resultados de búsqueda de Amazon, observará que sigue este formato:

https://www.amazon.com/search/s?k=<keyword>

Por ejemplo:

La URL de destino de su script debe utilizar ese formato, donde puede establecerse dinámicamente utilizando un argumento de entrada de Apify. Los parámetros de entrada que acepta un Actor se definen en el archivo input_schema.json, ubicado en el directorio .actor.

Definir el argumento keyword hace que el script sea personalizable, permitiendo a los usuarios especificar el término de búsqueda que prefieran. Para definir ese parámetro, sustituya el contenido de input_schema.json por el siguiente:

{
    "title": "Amazon Scraper",
    "type": "object",
    "schemaVersion": 1,
    "properties": {
        "keyword": {
            "title": "Search keyword",
            "type": "string",
            "description": "The keyword used to search products on Amazon",
            "editor": "textfield"
        }
    },
    "required": ["keyword"]
}

Esta configuración define un parámetro de palabra clave obligatorio de tipo cadena.

Para establecer el argumento de la palabra clave al ejecutar el Actor localmente, modifique el archivo INPUT.json dentro de storage/key_value_stores/default de la siguiente manera:

{
    "keyword": "laptop"
}

De esta forma, el Actor leerá el argumento de entrada de palabra clave, utilizando "portátil" como término de búsqueda.

Una vez que el Actor se despliega en la plataforma Apify, verá un campo de entrada donde puede personalizar este parámetro antes de ejecutar el Actor:

El campo de texto de palabra clave configurado en la consola de Apify

Tenga en cuenta que el archivo de entrada de un Actor Apify es main.py, ubicado en la carpeta src. Abra este archivo y modifíquelo a:

Leer el parámetro de palabra clave de los argumentos de entrada
Construir la URL de destino para la página de búsqueda de Amazon
Utilice Playwright para navegar hasta esa página

Al final de este paso, tu archivo main.py debería contener la lógica Python que se muestra a continuación:

from apify import Actor
from playwright.async_api import async_playwright


async def main() -> None:
    # Enter the context of the Actor
    async with Actor:
        # Retrieve the Actor input, and use default values if not provided
        actor_input = await Actor.get_input() or {}
        # Reading the "keyword" argument from the input data, assigning it the
        # value "laptop" as a default value
        keyword = actor_input.get("keyword")

        # Building the target url
        target_url = f"https://www.amazon.com/search/s?k={keyword}"

        # Launch Playwright and open a new browser context
        async with async_playwright() as playwright:
            # Configure the browser to launch in headless mode as per Actor configuration
            browser = await playwright.chromium.launch(
                headless=Actor.config.headless,
                args=["--disable-gpu"],
            )
            context = await browser.new_context()

            try:
                # Open a new page in the browser context and navigate to the URL
                page = await context.new_page()
                await page.goto(target_url)

                # Scraping logic...

            except Exception:
                Actor.log.exception(f"Cannot extract data from {target_url}")

            finally:
                await page.close()

El código anterior:

Inicializa un Actor Apify para gestionar el ciclo de vida del script
Recupera los argumentos de entrada utilizando Actor.get_input()
Extrae el argumento de la palabra clave de los datos de entrada
Construye la URL de destino utilizando una cadena f de Python
Lanza Playwright e inicia un navegador Chromium headless con la GPU desactivada
Crea un nuevo contexto de navegador, abre una página y navega a la URL de destino utilizando page.goto()
Registra cualquier error con Actor.log.exception()
Garantiza el cierre de la página Playwright tras la ejecución

¡Perfecto! Su Actor Apify está listo para aprovechar el Scraping Browser de Bright Data para un raspado web eficiente.

Paso 3: Integrar el explorador de raspado de Bright Data

Ahora, utilice la API de Playwright para capturar una pantalla después de conectarse a la página de destino:

await page.screenshot(path="screenshot.png")

Ejecute su Actor localmente, y generará un archivo screenshot.png en la carpeta del proyecto. Ábralo, y probablemente verá algo como esto:

Del mismo modo, es posible que aparezca la siguiente página de error de Amazon:

Como puedes ver, tu bot de web scraping ha sido bloqueado por las medidas anti-bot de Amazon. Este es solo uno de los muchos problemas que puedes encontrarte al hacer scraping en Amazon o en otros sitios web populares.

Olvídese de esos retos utilizando Scraping Browser de Bright Data, unasolución de scraping basada en la nube que proporciona escalabilidad ilimitada, rotación automática de IP, resolución de CAPTCHA y derivación antiscraping.

Para empezar, si aún no lo ha hecho, cree una cuenta de Bright Data. A continuación, inicie sesión en la plataforma. En la sección “Panel de usuario”, haga clic en el botón “Obtener productos proxy”:

Pulsar el botón "Obtener productos proxy

En la tabla “Mis zonas” de la página “Proxies e infraestructura de scraping”, seleccione la fila “scraping_browser”:

Active el producto pulsando el interruptor de encendido/apagado:

Ahora, en la pestaña “Configuración”, compruebe que las opciones “Dominios Premium” y “Solucionador CAPTCHA” están activadas para conseguir la máxima eficacia:

Activar las opciones "Dominios Premium" y "Solucionador CAPTCHA

En la pestaña “Visión general”, copie la cadena de conexión de Playwright Scraping Browser:

Copiar al portapapeles la cadena de conexión de Puppeteer / Playwright Scraping Browser

Añade la cadena de conexión a tu archivo main.py como una constante:

SBR_WS_CDP = "<YOUR_PLAYWRIGHT_SCRAPING_BROWSER_CONNECTION_STRING>"

Sustituya por la cadena de conexión que copió antes.

Nota: Si planea hacer público su Actor en Apify, debería definir SBR_WS_CDP como un argumento de entrada del Actor de Apify. De esta forma, los usuarios que adopten su Actor podrán integrar sus propias cadenas de conexión del Navegador de Raspado.

Ahora, actualiza la definición del navegador en main.py para usar Scraping Browser con Playwright:

browser = await playwright.chromium.connect_over_cdp(SBR_WS_CDP, timeout=120000)

Tenga en cuenta que el tiempo de espera de la conexión debe establecerse en un valor superior al habitual, ya que la rotación de IP a través de proxies y la resolución de CAPTCHA pueden llevar algún tiempo.

¡Listo! Usted integró exitosamente Scraping Browser en Playwright dentro de un Actor Apify.

Paso 4: Prepárese para raspar todas las listas de productos

Para escrapear listados de productos de Amazon, primero tienes que inspeccionar la página para entender su estructura HTML. Para ello, haz clic con el botón derecho del ratón en uno de los elementos de producto de la página y selecciona la opción “Inspeccionar”. Aparecerá la siguiente sección de DevTools:

Inspección del elemento del listado de productos

Aquí puede ver que cada elemento del listado de productos puede seleccionarse utilizando este selector CSS:

[data-component-type=\"s-search-result\"]

Dirigirse a atributos data-* personalizados es ideal porque estos atributos se emplean generalmente para pruebas o supervisión. Por lo tanto, tienden a permanecer constantes a lo largo del tiempo.

Ahora, utilice un localizador Playwright para recuperar todos los elementos de producto de la página:

product_elements = page.locator("[data-component-type=\"s-search-result\"]")

A continuación, itere sobre los elementos del producto y prepárese para extraer datos de ellos:

for product_element in await product_elements.all():
    # Data extraction logic...

¡Increíble! Es hora de implementar la lógica de extracción de datos de Amazon.

Paso 5: Implementar la lógica de raspado

En primer lugar, inspeccione un elemento individual del listado de productos:

Desde esta sección, puede recuperar la imagen del producto a partir del atributo src del elemento .s-image:

image_element = product_element.locator(".s-image").nth(0)
image = await image_element.get_attribute("src")

Tenga en cuenta que nth(0) es necesario para obtener el primer elemento HTML que coincida con el localizador.

A continuación, examine el título del producto:

Puede obtener la URL y el título del producto en los campos y

dentro del elemento [data-cy="title-recipe"], respectivamente:

title_header_element = product_element.locator("[data-cy=\"title-recipe\"]").nth(0)

link_element = title_header_element.locator("a").nth(0)
url = None if url_text == "javascript:void(0)" else "https://amazon.com" + url_text

title_element = title_header_element.locator("h2").nth(0)
title = await title_element.get_attribute("aria-label")

Observe la lógica utilizada para ignorar las URL “javascript:void(0)” (que aparecen en los productos de anuncios especiales) y la manipulación para convertir las URL de los productos en absolutas.

A continuación, consulte la sección de reseñas:

Desde [data-cy="reviews-block"], puede obtener la calificación de la reseña a partir de la etiqueta aria del elemento del elemento

rating_element =  product_element.locator("[data-cy=\"reviews-block\"] a").nth(0)
rating_text = await rating_element.get_attribute("aria-label")
rating_match = re.search(r"(\d+(\.\d+)?) out of 5 stars", rating_text)
if rating_match:
    rating = rating_match.group(1)
else:
    rating = None

Dado que el texto de calificación en aria-label tiene el formato “X de 5 estrellas”, puede extraer el valor de calificación X con una simple regex. Vea cómo usar regex para web scraping.

No olvide importar re de la biblioteca estándar de Python:

import re

Ahora, inspeccione el elemento de recuento de revisiones:

Extraer el número de reseñas del elemento dentro de [data-component-type="s-client-side-analytics"]:

review_count_element = product_element.locator("[data-component-type=\"s-client-side-analytics\"] a").nth(0)
review_count_text = await review_count_element.text_content()
review_count = int(review_count_text.replace(",", ""))

Observa la lógica directa para convertir una cadena como “2.539” en un valor numérico en Python.

Por último, inspeccione el nodo del precio del producto:

Recoger el precio del producto del elemento .a-offscreen dentro de [data-cy="precio-recipe"]:

price_element_locator = product_element.locator("[data-cy=\"price-recipe\"] .a-offscreen")
# If the price element is on the product element
if await price_element_locator.count() > 0:
    price = await price_element_locator.nth(0).text_content()
else:
    price = None

Dado que no todos los productos tienen un elemento de precio, debe manejar ese escenario comprobando el recuento del elemento de precio antes de intentar recuperar su valor.

Para que el guión funcione, actualice la importación de Playwright con:

from playwright.async_api import async_playwright, TimeoutError

¡Genial! La lógica de raspado de datos de productos de Amazon está completa.

Tenga en cuenta que el objetivo de este artículo no es profundizar en la lógica de raspado de Amazon. Para obtener más orientación, sigue nuestra guía sobre cómo raspar datos de productos de Amazon en Python.

Paso nº 6: Recopilar los datos raspados

Como última instrucción del bucle for, rellene un objeto producto con los datos raspados:

product = {
    "image": image,
    "url": url,
    "title": title,
    "rating": rating,
    "review_count": review_count,
    "price": price
}

A continuación, envíalo al conjunto de datos de Apify:

await Actor.push_data(product)

push_data() garantiza que los datos raspados se registran en Apify, lo que le permite acceder a ellos a través de la API o exportarlos en uno de los muchos formatos soportados (por ejemplo, CSV, JSON, Excel, JSONL, etc.).

Paso 7: Póngalo todo junto

Esto es lo que su Apify + Bright Data Actor main.py final debe contener:

from apify import Actor
from playwright.async_api import async_playwright, TimeoutError
import re

async def main() -> None:
    # Enter the context of the Actor
    async with Actor:
        # Retrieve the Actor input, and use default values if not provided
        actor_input = await Actor.get_input() or {}
        # Reading the "keyword" argument from the input data, assigning it the
        # value "laptop" as a default value
        keyword = actor_input.get("keyword")

        # Building the target url
        target_url = f"https://www.amazon.com/search/s?k={keyword}"

        # Launch Playwright and open a new browser context
        async with async_playwright() as playwright:
            # Your Bright Data Scraping API connection string
            SBR_WS_CDP = "wss://brd-customer-username-zone-scraping_browser:[email protected]:9222"

            # Configure Playwright to connect to Scraping Browser and open a new context
            browser = await playwright.chromium.connect_over_cdp(SBR_WS_CDP, timeout=120000)
            context = await browser.new_context()

            try:
                # Open a new page in the browser context and navigate to the URL
                page = await context.new_page()
                await page.goto(target_url)

                # Use a locator to select all product elements
                product_elements = page.locator("[data-component-type=\"s-search-result\"]")

                # Iterate over all product elements and scrape data from them
                for product_element in await product_elements.all():
                    # Product scraping logic
                    image_element = product_element.locator(".s-image").nth(0)
                    image = await image_element.get_attribute("src")

                    title_header_element = product_element.locator("[data-cy=\"title-recipe\"]").nth(0)

                    link_element = title_header_element.locator("a").nth(0)
                    url_text = await link_element.get_attribute("href")
                    url = None if url_text == "javascript:void(0)" else "https://amazon.com" + url_text

                    title_element = title_header_element.locator("h2").nth(0)
                    title = await title_element.get_attribute("aria-label")

                    rating_element =  product_element.locator("[data-cy=\"reviews-block\"] a").nth(0)
                    rating_text = await rating_element.get_attribute("aria-label")
                    rating_match = re.search(r"(\d+(\.\d+)?) out of 5 stars", rating_text)
                    if rating_match:
                        rating = rating_match.group(1)
                    else:
                        rating = None

                    review_count_element = product_element.locator("[data-component-type=\"s-client-side-analytics\"] a").nth(0)
                    review_count_text = await review_count_element.text_content()
                    review_count = int(review_count_text.replace(",", ""))

                    price_element_locator = product_element.locator("[data-cy=\"price-recipe\"] .a-offscreen")
                    # If the price element is on the product element
                    if await price_element_locator.count() > 0:
                        price = await price_element_locator.nth(0).text_content()
                    else:
                        price = None

                    # Populate a new dictionary with the scraped data
                    product = {
                        "image": image,
                        "url": url,
                        "title": title,
                        "rating": rating,
                        "review_count": review_count,
                        "price": price
                    }
                    # Add it to the Actor dataset
                    await Actor.push_data(product)
            except Exception:
                Actor.log.exception(f"Cannot extract data from {target_url}")

            finally:
                await page.close()

Como puede ver, la integración de Bright Data’s Scraping Browser con la plantilla “Playwright + Chrome” de Apify es sencilla y sólo requiere unas pocas líneas de código.

Paso 8: Despliegue en Apify y ejecute el actor

Para desplegar su Actor local en Apify, ejecute el siguiente comando en la carpeta de su proyecto:

apify push

Si aún no ha iniciado sesión, se le pedirá que se autentique a través de la CLI de Apify.

Una vez finalizado el despliegue, se le formulará la siguiente pregunta:

✔ Do you want to open the Actor detail in your browser?

Responda con “Y” o “sí” para ser redirigido a la página de Actor en su Consola de Apify:

Si lo prefiere, puede acceder manualmente a la misma página:

Iniciar sesión en Apify desde el navegador
Navegar a la consola
Visitar la página “Actor

Haga clic en el botón “Iniciar Actor” para iniciar su Actor Amazon Scraper. Como era de esperar, se le pedirá que proporcione una palabra clave. Pruebe con algo como “silla de juegos”:

Rellenar el elemento de entrada del campo de texto de palabras clave

A continuación, pulse “Guardar e iniciar” para ejecutar el Actor y raspar los listados de productos “silla de juegos” de Amazon.

Una vez finalizado el scraping, verá los datos recuperados en la sección Salida:

Para exportar los datos, vaya a la pestaña “Almacenamiento”, seleccione la opción “CSV” y pulse el botón “Descargar”:

El archivo CSV descargado contendrá los siguientes datos:

¡Et voilà! La integración Scraping Browser + Apify de Bright Data funciona a las mil maravillas. No más CAPTCHAs o bloqueos al raspar Amazon o cualquier otro sitio.

[Extra] Integración de Bright Data Proxy en Apify

Utilizar un producto de scraping como Scraping Browser o Web Unlocker directamente en Apify es útil y sencillo.

Al mismo tiempo, suponga que ya tiene un Actor en Apify y sólo necesita mejorarlo con proxies (por ejemplo, para evitar prohibiciones de IP). Bueno, recuerde que puede integrar proxies de Bright Data directamente en su Actor de Apify, como se describe en nuestra documentación o guía de integración.

Conclusión

En este tutorial, usted aprendió a construir un Actor Apify que se integra con Scraping Browser en Playwright para programáticamente recopilar datos de Amazon. Empezamos desde cero, recorriendo todos los pasos para construir un script de scraping local y luego desplegarlo en Apify.

Ahora, usted entiende los beneficios de utilizar una herramienta profesional de scraping como Scraping Browser para su cloud scraping en Apify. Siguiendo los mismos o similares procedimientos, Apify soporta todos los demás productos de Bright Data:

Servicios de proxy: 4 tipos diferentes de proxies para eludir las restricciones de ubicación, incluidos más de 150 millones de IP residenciales.
API de Web Scraper: Puntos finales dedicados para extraer datos web frescos y estructurados de más de 100 dominios populares.
API SERP: API para manejar toda la gestión de desbloqueo en curso para SERP y extraer una página.

Regístrese ahora en Bright Data y pruebe gratis nuestros servicios proxy interoperables y nuestros productos de scraping.

Prueba gratuita

Comienza con Google

No se requiere tarjeta de crédito

Web Scraping con Bright Data’s Scraping Browser en Apify