Raspagem da Web usando o navegador de raspagem da Bright Data na Apify

Nesta postagem do blog, você aprenderá:

• O que é o Apify
• Por que usar o Scraping Browser com o Apify é um cenário em que todos saem ganhando
• Como integrar o navegador de raspagem da Bright Data em um script Apify Python
• Como usar os proxies da Bright Data na Apify

Vamos mergulhar de cabeça!

O que é a Apify?

O Apify é uma plataforma de extração de dados e raspagem da Web de pilha completa. Ela permite que você crie e execute ferramentas personalizadas de raspagem da Web – conhecidas como Actors –na nuvem. Esses Atores automatizam tarefas relacionadas à coleta, ao processamento e à automação de dados.

No Apify, você pode monetizar seus scripts de raspagem, tornando-os públicos e disponíveis para outros usuários. Se você planeja utilizar seu Actor de forma privada ou torná-lo público, as soluções de raspagem da Bright Data ajudarão a tornar seu raspador mais confiável e eficaz.

Por que usar o navegador de raspagem da Bright Data na Apify

Para apreciar o valor do Navegador de raspagem da Bright Data, você precisa entender o que é a ferramenta e o que ela oferece.

A maior limitação das ferramentas de automação de navegadores não são suas APIs, mas sim os navegadores que elas controlam. O Scraping Browser é um navegador da Web de última geração projetado especificamente para raspagem da Web. Em particular, ele vem com os seguintes recursos principais:

• Impressões digitais confiáveis de TLS para evitar a detecção
• Escalabilidade ilimitada para extração de dados em grande escala
• Rotação de IP integrada com base em uma rede de proxy de 150 milhões de IPs
• Novas tentativas automáticas para lidar com solicitações com falha
• Recursos de resolução de CAPTCHA

O Scraping Browser é compatível com todas as principais estruturas de automação de navegador, incluindo Playwright, Puppeteer e Selenium. Portanto, você não precisa aprender uma nova API ou instalar dependências de terceiros. Basta integrá-lo diretamente ao seu script de raspagem de automação de navegador existente.

Agora, usar o Scraping Browser com o Apify traz ainda mais vantagens, resultando nos seguintes benefícios:

• Redução dos custos de nuvem: Os navegadores consomem recursos significativos, o que leva a um maior uso da CPU e da RAM. O Scraping Browser, hospedado na nuvem com escalabilidade ilimitada garantida, reduz os custos da nuvem durante as execuções do ator no Apify. Como o Apify cobra pelo uso do servidor, mesmo quando se leva em conta as taxas do Scraping Browser, essa configuração pode resultar em economia de custos.
• Ferramenta completa anti-bot bypass: O Scraping Browser resolve proibições de IP, desafios de CAPTCHA, problemas de impressão digital do navegador e outras barreiras antirraspagem. Isso torna seu processo de raspagem mais eficiente e menos propenso a interrupções.
• Integração de proxy incorporada: O Scraping Browser inclui gerenciamento de proxy, para que você não precise mais se preocupar com a manutenção e a rotação manual de proxies.
• Benefícios do Apify: O uso do Navegador de raspagem em um ator do Apify na nuvem (em vez de um script genérico) oferece benefícios adicionais, tais como

  :O espaço reservado de Polylang não é modificado

A integração Bright Data + Apify não apenas simplifica seu fluxo de trabalho de raspagem, mas também aumenta a confiabilidade. Além disso, ela reduz o tempo e o esforço necessários para colocar seu bot de raspagem da Web on-line.

Como integrar o navegador de raspagem da Bright Data na Apify: Guia passo a passo

O site de destino desta seção será a Amazon, uma plataforma rica em informações, mas notória por suas rigorosas medidas anti-bot. Sem as ferramentas certas, é provável que você encontre o infame CAPTCHA da Amazon, bloqueando suas tentativas de raspagem:

Nesta seção, criaremos um Actor de raspagem que utiliza o navegador de raspagem da Bright Data para extrair dados de uma página genérica de pesquisa de produtos da Amazon:

Observação: o Actor será escrito em Python, mas lembre-se de que o Apify também oferece suporte a JavaScript.

Siga as etapas abaixo para saber como integrar as ferramentas de raspagem da Bright Data com o Apify!

Pré-requisitos

Para seguir este tutorial, você precisa atender aos seguintes pré-requisitos:

• Python 3.8+ instalado localmente: Para desenvolver e criar o script Actor local.
• Node.js instalado localmente: Para instalar a CLI do Apify.
• Uma conta do Apify: Para implantar o Actor local na plataforma Apify.
• Uma conta da Bright Data: Para acessar o Navegador de raspagem.

Etapa 1: Configuração do projeto

A maneira mais fácil de configurar um novo projeto do Apify Actor é usando a CLI do Apify. Primeiro, instale-o globalmente via Node.js com o seguinte comando:

npm install -g apify-cli

Em seguida, crie um novo projeto Apify executando:

npx apify-cli create

Você será solicitado a responder a algumas perguntas. Responda da seguinte forma:

✔ 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

Dessa forma, a CLI do Apify criará um novo Python Actor na pasta amazon-scraper usando o modelo “Playwright + Chrome”. Se você não estiver familiarizado com essas ferramentas, leia nosso guia sobre raspagem da Web do Playwright.

Observação: Um modelo Selenium ou Puppeteer também funcionaria, pois o navegador de raspagem da Bright Data se integra a qualquer ferramenta de automação de navegador.

Seu projeto Apify Actor terá a seguinte estrutura:

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/
    └── ...

Carregue a pasta amazon-scraper em seu IDE Python preferido, como o Visual Studio Code com a extensão Python ou o PyCharm Community Edition.

Agora, lembre-se de que, para executar o Actor localmente, os navegadores do Playwright devem estar instalados. Para isso, primeiro ative a pasta do ambiente virtual (.venv) dentro do diretório do projeto. No Windows, execute:

.venv/Scripts/activate

De forma equivalente, no Linux/macOS, inicie:

source .venv/bin/activate

Em seguida, instale as dependências necessárias do Playwright executando:

playwright install --with-deps

Maravilhoso! Agora você pode executar seu Actor localmente com:

apify run

Seu projeto Apify agora está totalmente configurado e pronto para ser integrado ao Navegador de raspagem da Bright Data!

Etapa 2: Conecte-se à página de destino

Se você der uma olhada no URL de uma página de resultados de pesquisa da Amazon, verá que ele segue esse formato:

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

Por exemplo:

O URL de destino de seu script deve usar esse formato, onde pode ser definido dinamicamente usando um argumento de entrada do Apify. Os parâmetros de entrada que um Actor aceita são definidos no arquivo input_schema.json, localizado no diretório .actor.

A definição do argumento keyword torna o script personalizável, permitindo que os usuários especifiquem o termo de pesquisa de sua preferência. Para definir esse parâmetro, substitua o conteúdo de input_schema.json pelo seguinte:

{
    "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"]
}

Essa configuração define um parâmetro de palavra-chave obrigatório do tipo string.

Para definir o argumento da palavra-chave ao executar o Actor localmente, modifique o arquivo INPUT.json dentro de storage/key_value_stores/default da seguinte forma:

{
    "keyword": "laptop"
}

Dessa forma, o Actor lerá o argumento de entrada da palavra-chave, usando "laptop" como o termo de pesquisa.

Depois que o Ator for implantado na plataforma Apify, você verá um campo de entrada no qual poderá personalizar esse parâmetro antes de executar o Ator:

Lembre-se de que o arquivo de entrada de um Apify Actor é main.py, localizado na pasta src. Abra esse arquivo e modifique-o para:

1. Ler o parâmetro de palavra-chave dos argumentos de entrada
2. Construa o URL de destino para a página de pesquisa da Amazon
3. Use o Playwright para navegar até essa página

Ao final desta etapa, seu arquivo main.py deverá conter a lógica Python abaixo:

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()

O código acima:

1. Inicializa um Apify Actor para gerenciar o ciclo de vida do script
2. Recupera argumentos de entrada usando Actor.get_input()
3. Extrai o argumento da palavra-chave dos dados de entrada
4. Constrói o URL de destino usando uma string f do Python
5. Inicia o Playwright e inicia um navegador Chromium sem cabeça com a GPU desativada
6. Cria um novo contexto de navegador, abre uma página e navega até o URL de destino usando page.goto()
7. Registra quaisquer erros com Actor.log.exception()
8. Garante que a página do Playwright seja fechada após a execução

Perfeito! Seu Apify Actor está pronto para aproveitar o navegador de raspagem da Bright Data para uma raspagem eficiente da Web.

Etapa nº 3: Integrar o navegador de raspagem da Bright Data

Agora, use a API do Playwright para capturar uma imagem de tela depois de se conectar à página de destino:

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

Execute seu Actor localmente e ele gerará um arquivo screenshot.png na pasta do projeto. Abra-o e você provavelmente verá algo parecido com isto:

Da mesma forma, você pode receber a seguinte página de erro da Amazon:

Como você pode ver, seu bot de raspagem da Web foi bloqueado pelas medidas anti-bot da Amazon. Esse é apenas um dos muitos desafios que você pode encontrar ao fazer scraping da Amazon ou de outros sites populares.

Esqueça esses desafios usando o Navegador de raspagem da Bright Data – umasolução de raspagem baseada em nuvem que oferece escalabilidade ilimitada, rotação automática de IP, solução de CAPTCHA e desvio anti-raspagem.

Para começar, se você ainda não o fez, crie uma conta na Bright Data. Em seguida, faça login na plataforma. Na seção “User Dashboard” (Painel do usuário), clique no botão “Get proxy products” (Obter produtos proxy):

Na tabela “My Zones” (Minhas zonas) na página “Proxies & Scraping Infrastructure” (Proxies e infraestrutura de raspagem), selecione a linha “scraping_browser” (navegador de raspagem):

Ative o produto alternando a chave liga/desliga:

Agora, na guia “Configuration” (Configuração), verifique se as opções “Premium domains” (Domínios premium) e “CAPTCHA Solver” (Solucionador de CAPTCHA) estão ativadas para obter o máximo de eficácia:

Na guia “Overview” (Visão geral), copie a string de conexão do Playwright Scraping Browser:

Adicione a string de conexão ao seu arquivo main.py como uma constante:

SBR_WS_CDP = "<YOUR_PLAYWRIGHT_SCRAPING_BROWSER_CONNECTION_STRING>"

Substitua pela string de conexão que você copiou anteriormente.

Observação: se você planeja tornar seu Actor público no Apify, deve definir SBR_WS_CDP como um argumento de entrada do Apify Actor. Dessa forma, os usuários que adotarem seu Actor poderão integrar suas próprias strings de conexão do Scraping Browser.

Agora, atualize a definição do navegador em main.py para usar o navegador de raspagem com o Playwright:

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

Observe que o tempo limite da conexão deve ser definido com um valor mais alto do que o normal, pois a rotação de IPs por meio de proxies e a resolução de CAPTCHA podem levar algum tempo.

Pronto! Você integrou com sucesso o Scraping Browser ao Playwright em um Apify Actor.

Etapa nº 4: Prepare-se para raspar todas as listagens de produtos

Para extrair listagens de produtos da Amazon, primeiro você precisa inspecionar a página para entender sua estrutura HTML. Para isso, clique com o botão direito do mouse em um dos elementos do produto na página e selecione a opção “Inspect” (Inspecionar). A seção DevTools a seguir será exibida:

Aqui, você pode ver que cada elemento da listagem de produtos pode ser selecionado usando esse seletor CSS:

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

O direcionamento de atributos personalizados de dados-* é ideal porque esses atributos são geralmente empregados para testes ou monitoramento. Portanto, eles tendem a permanecer consistentes ao longo do tempo.

Agora, use um localizador do Playwright para recuperar todos os elementos do produto na página:

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

Em seguida, itere sobre os elementos do produto e prepare-se para extrair dados deles:

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

Incrível! É hora de implementar a lógica de extração de dados da Amazon.

Etapa nº 5: Implementar a lógica de raspagem

Primeiro, inspecione um elemento individual da listagem de produtos:

Nessa seção, você pode recuperar a imagem do produto do atributo src do elemento .s-image:

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

Observe que nth(0) é necessário para obter o primeiro elemento HTML correspondente ao localizador.

Em seguida, inspecione o título do produto:

Você pode obter o URL e o título do produto nos campos e

dentro do 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 a lógica usada para ignorar os URLs “javascript:void(0)” (que aparecem em produtos de anúncios especiais) e o tratamento para converter os URLs dos produtos em URLs absolutos.

Em seguida, examine a seção de avaliação:

Em [data-cy="reviews-block"], você pode obter a classificação da avaliação no aria-label do elemento 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

Como o texto da classificação em aria-label está no formato “X de 5 estrelas”, você pode extrair o valor X da classificação com uma simples regex. Veja como usar regex para raspagem da Web.

Não se esqueça de importar re da Biblioteca Padrão do Python:

import re

Agora, inspecione o elemento de contagem de revisões:

Extraia o número de avaliações do elemento no elemento [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(",", ""))

Observe a lógica direta para converter uma cadeia de caracteres como “2.539” em um valor numérico em Python.

Por fim, inspecione o nó de preço do produto:

Colete o preço do produto do elemento .a-offscreen dentro de [data-cy="price-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

Como nem todos os produtos têm um elemento de preço, você deve lidar com esse cenário verificando a contagem do elemento de preço antes de tentar recuperar seu valor.

Para fazer o script funcionar, atualize a importação do Playwright com:

from playwright.async_api import async_playwright, TimeoutError

Muito bem! A lógica de raspagem de dados de produtos da Amazon está completa.

Observe que o objetivo deste artigo não é se aprofundar na lógica de coleta de dados da Amazon. Para obter mais orientações, siga nosso guia sobre como extrair dados de produtos da Amazon em Python.

Etapa nº 6: coletar os dados extraídos

Como a última instrução do loop for, preencha um objeto de produto com os dados extraídos:

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

Em seguida, envie-o para o conjunto de dados do Apify:

await Actor.push_data(product)

push_data() garante que os dados raspados sejam registrados no Apify, permitindo que você os acesse via API ou os exporte em um dos vários formatos compatíveis (por exemplo, CSV, JSON, Excel, JSONL, etc.).

Etapa nº 7: Juntar tudo

Isso é o que o main.py final do Apify + Bright Data Actor deve conter:

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-hl_4bcb8ada-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 você pode ver, a integração do navegador de raspagem da Bright Data com o modelo “Playwright + Chrome” da Apify é simples e requer apenas algumas linhas de código.

Etapa 8: implantar no Apify e executar o ator

Para implantar seu Actor local no Apify, execute o seguinte comando na pasta do projeto:

apify push

Se ainda não tiver feito login, você será solicitado a se autenticar por meio da CLI do Apify.

Quando a implantação estiver concluída, você receberá a seguinte pergunta:

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

Responda com “Y” ou “yes” para ser redirecionado para a página do Actor em seu Console da Apify:

Se preferir, você pode acessar manualmente a mesma página:

1. Como fazer login na Apify em seu navegador
2. Navegando até o console
3. Visitar a página “Ator

Clique no botão “Start Actor” para iniciar o Amazon Scraper Actor. Como esperado, você será solicitado a fornecer uma palavra-chave. Tente algo como “cadeira para jogos”:

Depois disso, pressione “Save & Start” (Salvar e iniciar) para executar o Actor e extrair as listagens de produtos de “cadeira para jogos” da Amazon.

Quando a raspagem estiver concluída, você verá os dados recuperados na seção Output (Saída):

Para exportar os dados, vá para a guia “Storage” (Armazenamento), selecione a opção “CSV” e pressione o botão “Download”:

O arquivo CSV baixado conterá os seguintes dados:

E pronto! O navegador de raspagem da Bright Data + integração com o Apify funciona perfeitamente. Não há mais CAPTCHAs ou bloqueios ao raspar a Amazon ou qualquer outro site.

[Extra] Integração do Bright Data Proxy na Apify

Usar um produto de raspagem como o Scraping Browser ou o Web Unlocker diretamente no Apify é útil e direto.

Ao mesmo tempo, suponha que você já tenha um Actor no Apify e só precise aprimorá-lo com proxies (por exemplo, para evitar proibições de IP). Bem, lembre-se de que você pode integrar os proxies da Bright Data diretamente em seu Apify Actor, conforme descrito em nossa documentação ou guia de integração.

Conclusão

Neste tutorial, você aprendeu a criar um Apify Actor que se integra ao Scraping Browser no Playwright para coletar dados da Amazon de forma programática. Começamos do zero, percorrendo todas as etapas para criar um script de raspagem local e, em seguida, implantá-lo no Apify.

Agora, você entende os benefícios de usar uma ferramenta de raspagem profissional como o Scraping Browser para sua raspagem na nuvem no Apify. Seguindo os mesmos procedimentos ou procedimentos semelhantes, o Apify oferece suporte a todos os outros produtos Bright Data:

• Serviços de proxy: 4 tipos diferentes de proxies para contornar restrições de localização, incluindo mais de 150 milhões de IPs residenciais
• APIs do Web Scraper: Pontos de extremidade dedicados para extrair dados da Web novos e estruturados de mais de 100 domínios populares.
• API SERP: API para lidar com todo o gerenciamento de desbloqueio contínuo para SERP e extrair uma página

Inscreva-se agora na Bright Data e teste gratuitamente nossos serviços de proxy interoperáveis e produtos de raspagem!