Como construir web scrapers de nível de produção com Scrapling e Scrapeless em Python

Principais Conclusões:

• Scrapling envia três fetchers e seletores adaptativos. O HTTP Fetcher (com impersonação de TLS de navegador), o DynamicFetcher apoiado pelo Playwright e o StealthyFetcher cobrem páginas estáticas, páginas renderizadas em JavaScript e anti-bot de nível médio em uma única biblioteca Python — e seletores adaptativos localizam elementos pela estrutura, não apenas por um caminho CSS frágil.
• A escalada é HTTP → stealth → navegador em nuvem. Comece com o fetcher mais barato que funciona; quando a stealth local atinge a reputação do IP, gerenciadores de bot avançados ou conteúdo bloqueado geograficamente, você escala para um navegador em nuvem sem reescrever seu código de parsing.
• A integração é uma linha. Aponte o fetcher Playwright do Scrapling para uma sessão Scrapeless via CDP — DynamicFetcher.fetch(url, cdp_url=session.browser_ws_endpoint) — e a renderização, saída de proxy e impressão digital se movem para o lado da nuvem.
• Scrapeless lida com a saída e a impressão digital. O Scrapeless Scraping Browser opera através de proxies residenciais em mais de 195 países e randomiza a impressão digital do navegador por sessão, de modo que o navegador em nuvem renderize páginas que um navegador stealth local filtra.
• Seletores adaptativos sobrevivem à deriva do DOM. Scrapling pode realocar um elemento após uma mudança de layout correspondendo seus atributos e posição anteriores, assim um scraper continua retornando linhas quando o site alvo roda sua marcação.
• Grátis para começar. Novas contas Scrapeless incluem a execução gratuita do Scraping Browser — inscreva-se em Scrapeless.

Introdução: Quando a stealth local não tem mais caminho

Páginas dinâmicas, pesadas em JavaScript e protegidas contra bots são onde scrapers HTTP simples falham silenciosamente. Um script requests + BeautifulSoup retorna HTTP 200 e um conjunto de resultados vazio: a marcação que ele analisou nunca continha os dados, porque os preços, listagens ou avaliações são injetados por JavaScript após a resposta inicial. A página parece boa em um navegador e parece vazia para seu scraper.

Scrapling eleva o padrão. É uma biblioteca de scraping Python rápida com três fetchers — um HTTP Fetcher que impersona o handshake TLS de um navegador real, um DynamicFetcher suportado pelo Playwright para renderização em JavaScript, e um StealthyFetcher que adiciona patches de stealth e tratamento do Cloudflare — além de seletores adaptativos que sobrevivem a mudanças no DOM. Isso cobre páginas estáticas e uma boa quantidade de anti-bot de nível médio. Mas um navegador rodando em seu laptop ainda carrega um IP de datacenter ou residencial com uma reputação conhecida, e gerenciadores de bot avançados imprimem digitais da automação independentemente de quão limpa seja a stealth no nível da página. Nesse ponto, a página é renderizada para um humano e é desafiada por você.

Este tutorial constrói um pipeline Python em dois níveis. O Nível 1 é o Scrapling por conta própria — a ferramenta certa para páginas estáticas e protegidas de nível médio. O Nível 2 roteia o DynamicFetcher do Scrapling através do Scrapeless Scraping Browser via CDP, de modo que a renderização acontece do lado da nuvem por trás de proxies residenciais e impressão digital anti-detecção por sessão enquanto seu código de parsing do Scrapling permanece exatamente o mesmo. Para o mesmo primitivo do Scrapeless Scraping Browser movido através de um framework de agente em vez de um fetcher, veja o post de integração LangChain.

O Que Você Pode Construir

O padrão de dois níveis — fetchers do Scrapling na frente, Scrapeless Scraping Browser atrás da escalada — atende a muitos dos trabalhos que quebram um scraper HTTP simples:

• Monitores de preços e estoques em vitrines SPA. Renderize páginas de produtos de aplicativo de página única cujos preços são hidratados através de um segundo XHR, depois extraia os números que Scrapling analisa do DOM renderizado.
• Extração adjacente a SERP. Extraia blocos de resultados orgânicos e trechos de páginas de resultados estilo busca que são enviados como JavaScript, depois navegue por eles com seletores adaptativos.
• Listas de leads de diretórios JavaScript. Navegue em sites de listagem de negócios e diretórios de membros que renderizam linhas do lado do cliente e colete campos de contato em registros tipados.
• Capturas geo-específicas via saída residencial. Capture as listagens, preços ou disponibilidade que um usuário local veria fixando o país do proxy Scrapeless, em vez de qualquer que seja o IP do seu escritório.
• Ingestão RAG de páginas renderizadas. Renderize páginas de editores e documentação para limpar conteúdo para um pipeline de embeddings, então a camada de recuperação indexa o que a página realmente exibe, não uma concha vazia.
• Scrapers resilientes que sobrevivem a mudanças de layout. Confie nos seletores adaptativos do Scrapling para que um scraper agendado continue retornando linhas após o site alvo reorganizar seu DOM, em vez de falhar silenciosamente na próxima execução.
• Extração de alvos difíceis atrás de anti-bots avançados. Escale o mesmo código do Scrapling para o Scrapeless Scraping Browser quando um site pré-carregar um gerenciador de bot avançado que a stealth local não pode limpar.
  Na Scrapeless, acessamos apenas dados disponíveis publicamente, enquanto cumprimos rigorosamente as leis, regulamentos e políticas de privacidade dos sites aplicáveis. O conteúdo deste post é apenas para fins de demonstração.

Por que combinar Scrapling com Scrapeless

Scrapling lida com análise, ergonomia de fetcher e seletores adaptativos; o Scrapeless Scraping Browser cuida da evasão que um navegador local não pode. Os dois se conectam de forma limpa, pois a transferência é um único endpoint CDP.

• Navegador em nuvem anti-detecção. O Scrapeless Scraping Browser executa um Chromium desenvolvido internamente com renderização completa em JavaScript do lado da nuvem, então SPAs, feeds de rolagem infinita e painéis carregados de forma preguiçosa são hidratados antes que o Scrapling os analise.
• Proxies residenciais em mais de 195 países. Defina proxy_country ao criar uma sessão e o navegador em nuvem se conecta a IPs residenciais reais na região que você direciona, de modo que páginas geograficamente limitadas retornem o que um usuário local vê.
• Randomização de impressão digital por sessão. Cada sessão recebe uma impressão digital aleatória — agente do usuário, fuso horário, WebGL e canvas — para que execuções repetidas não se tornem uma única identidade detectável.
• Drop-in cdp_url. Passe o endpoint de sessão Scrapeless como cdp_url para DynamicFetcher.fetch(...) e nada mais na API do Scrapling muda — mesmos seletores, mesmos objetos de resultado, mesmo código de análise.
• Persistência de sessão via session_ttl. Mantenha uma sessão aberta em várias carregamentos de página definindo session_ttl na criação, assim, cookies quentes e estado de navegação são mantidos entre solicitações em uma única execução.

O tempo de execução é grátis para começar e escala com o uso — veja preços da Scrapeless para os níveis, e obtenha sua chave de API no plano gratuito em Scrapeless.

Como Scrapling se compara a requests, BeautifulSoup e Scrapy

Se sua pilha atual é requests + BeautifulSoup ou Scrapy, aqui está onde Scrapling se encaixa e o que muda assim que o navegador em nuvem Scrapeless se coloca atrás disso.

A progressão é aditiva. Mantenha requests/BeautifulSoup onde já funciona, recorra aos fetchers do Scrapling quando uma página precisar de um navegador ou HTTP ciente de impressão digital, e roteie o Scrapling pelo Scrapeless Scraping Browser via cdp_url quando a renderização local for filtrada. O código de análise — page.css(...), page.xpath(...) — permanece idêntico em todos os três.

Pré-requisitos

Antes de começar, certifique-se de que você tem:

• Python 3.10+ — Scrapling 0.4.8 requer isso.
• pip — para instalar os pacotes abaixo.
• Uma conta Scrapeless e chave de API — inscreva-se para o plano gratuito no Site da Scrapeless, depois pegue sua chave em Configurações → Gerenciamento de Chaves de API.
• Familiaridade básica com seletores CSS/XPath e o terminal — você usará ambos para buscar páginas e extrair valores delas.

Instalação

Você só precisa de dois pacotes: Scrapling para buscar e analisar, e o oficial SDK Scrapeless para criar sessões de navegador em nuvem.

1. Instale Scrapling e o SDK Scrapeless

pip install "scrapling[fetchers]" scrapeless
scrapling install   # busca navegadores locais para DynamicFetcher / StealthyFetcher (ignore se você usar apenas o navegador em nuvem remoto Scrapeless via cdp_url)

scrapling[fetchers] fornece a camada de busca e análise (as classes Fetcher, DynamicFetcher e StealthyFetcher além de uma API de seletores semelhante ao parsel), enquanto scrapeless é o SDK oficial que cria sessões do Scrapeless Scraping Browser e fornece um endpoint CDP para se conectar.

2. Defina sua chave de API Scrapeless

Exporte sua chave para que o SDK possa lê-la:

export SCRAPELESS_API_KEY=your_api_token_here

No Windows, use setx SCRAPELESS_API_KEY "seu_token_api_aqui" (persistente, nova shell) ou $env:SCRAPELESS_API_KEY="seu_token_api_aqui" (sessão atual do PowerShell). O SDK Scrapeless lê essa variável automaticamente — você não precisa passar a chave no código.

3. Teste de fumaça da instalação

Confirme o ambiente importando os três fetchers e extraindo alguns valores de uma página estática:

from scrapling.fetchers import Fetcher, DynamicFetcher, StealthyFetcher

page = Fetcher.get("https://quotes.toscrape.com/")
print(page.status, len(page.css("span.text::text")), "citações")  # -> 200 10 citações

Se você ver 200 10 citações, o Scrapling está instalado e analisando corretamente, e você está pronto para conectar o navegador de raspagem Scrapeless.

Etapa 1 — Os três fetchers do Scrapling

O Scrapling oferece três fetchers que trocam velocidade por evasão. A regra geral é escolher o mais leve que retorna os dados de que precisa, e então escalar apenas quando uma solicitação voltar bloqueada ou vazia: comece com Fetcher para HTTP simples, passe para DynamicFetcher quando a página precisar de JavaScript para renderizar, e use StealthyFetcher quando uma camada anti-bot estiver no caminho.

Todos os três importam do mesmo módulo e retornam uma resposta semelhante à parsel, então a API do seletor (.css(...), .xpath(...)) é idêntica, independentemente de qual fetcher produziu a página.

from scrapling.fetchers import Fetcher

# Fetch HTTP com impersonificação de TLS do navegador; retorna uma Resposta semelhante a parsel.
page = Fetcher.get("https://books.toscrape.com/", impersonate="chrome", stealthy_headers=True)
title = page.css("article.product_pod h3 a::attr(title)")  # -> título do primeiro livro

from scrapling.fetchers import DynamicFetcher

# O Playwright renderiza o JS e, em seguida, retorna a página hidratada como uma Resposta semelhante a parsel.
# Necessita de um navegador local (execute `scrapling install`) ou um remoto via cdp_url (próxima etapa).
page = DynamicFetcher.fetch("https://quotes.toscrape.com/js/", network_idle=True)
quotes = page.css("span.text::text")  # -> as citações renderizadas em JS, agora visíveis

from scrapling.fetchers import StealthyFetcher

# O Stealth Playwright tenta o handshake anti-bot e, em seguida, retorna a página.
page = StealthyFetcher.fetch("https://example.com/protected-page",
                             solve_cloudflare=True, block_webrtc=True, hide_canvas=True)
content = page.css("main ::text")  # -> texto da página após o desafio ser resolvido

Etapa 2 — Adicionando um proxy (e onde a furtividade local para)

Um IP de datacenter limpo é uma das primeiras coisas que um gerenciador de bots sinaliza. Roteando solicitações através de proxies residenciais corta esses bloqueios de reputação de IP porque o endereço de saída parece uma conexão doméstica comum. Cada fetcher do Scrapling aceita um proxy através do mesmo argumento proxy=, para que você possa adicionar um sem mudar o restante do seu código.

from scrapling.fetchers import Fetcher, StealthyFetcher

# Passe uma string de proxy para qualquer fetcher via proxy=.
page = Fetcher.get("https://books.toscrape.com/",
                   proxy="http://<user>:<pass>@<host>:<port>")

# StealthyFetcher aceita o mesmo argumento enquanto trabalha no desafio anti-bot.
page = StealthyFetcher.fetch("https://example.com/protected-page",
                            proxy="http://<user>:<pass>@<host>:<port>",
                            solve_cloudflare=True)

É aqui que o Scrapeless se encaixa na história do proxy. O Scrapeless fornece proxies residenciais em mais de 195 países, e há duas maneiras de colocá-los na frente do Scrapling. O caminho mais simples aplica-os no nível da sessão do navegador em nuvem: quando você conecta DynamicFetcher a uma sessão do navegador de raspagem Scrapeless, você fixa a saída com proxy_country (mostrado na próxima etapa) e nunca toca em uma string de proxy. O Scrapeless também oferece um produto de proxy autônomo cujos credenciais de gateway são inseridas diretamente no argumento proxy= do Scrapling — veja soluções de proxy Scrapeless para a oferta e docs.scrapeless.com para a string de gateway exata a ser colada no lugar do placeholder <user>:<pass>@<host>:<port> acima.

Um bom proxy corrige o problema de reputação de IP, mas não corrige tudo. Navegadores locais furtivos ainda são filtrados por gerenciadores de bots avançados e falham em JavaScript pesado do lado do cliente, não importa quão limpo seja o IP de saída. É exatamente aí que o navegador em nuvem do Scrapeless assume — abordado na próxima etapa.

Etapa 3 — Roteando Scrapling através do navegador em nuvem Scrapeless (cdp_url)

Quando a furtividade local acaba — renderização pesada do lado do cliente, um gerenciador de bots avançado ou uma página que só é resolvida a partir de um país específico — crie uma sessão Scrapeless com o SDK e passe seu endpoint CDP para o Scrapling. O SDK cria a sessão; o Scrapling a direciona. O proxy residencial (proxy_country) e a impressão digital do navegador são gerenciados do lado da nuvem pelo Scrapeless Scraping Browser, então seu código Scrapling permanece o mesmo, exceto por um argumento extra: cdp_url.

from scrapeless import Scrapeless
from scrapeless.types import ICreateBrowser
from scrapling.fetchers import DynamicFetcher

client = Scrapeless()  # lê SCRAPELESS_API_KEY
session = client.browser.create(ICreateBrowser(proxy_country="US", session_ttl=240))

page = DynamicFetcher.fetch(
    "https://quotes.toscrape.com/js/",
    cdp_url=session.browser_ws_endpoint,
    network_idle=True,
)

quotes = page.css("span.text::text")
authors = page.css("small.author::text")

session.browser_ws_endpoint é uma URL WebSocket CDP no formato wss://browser.scrapeless.com/browser?token=...&proxy... — Scrapling se conecta a ela exatamente como se conectaria a um navegador local. O antes/depois é o ponto principal: um simples Fetcher.get em https://quotes.toscrape.com/js/ retorna 0 citações porque o HTTP não pode executar o JavaScript da página, enquanto a mesma página buscada através do Scrapeless cdp_url renderiza 10 citações (mais seus autores). Esse é um comportamento da plataforma, não um truque de ajuste — o navegador em nuvem executa o JS, e então o Scrapling analisa o DOM resultante.

StealthyFetcher.fetch(...) aceita cdp_url com o mesmo padrão quando você quer a camada de furtividade do Scrapling em cima do navegador em nuvem.

Passo 4 — Seletores adaptativos que sobrevivem à deriva do DOM

Seletores são a parte mais frágil de qualquer scraper: um redesign renomeia uma classe ou move um elemento, e cada chamada css(...) retorna silenciosamente nada. O modo adaptativo do Scrapling se resguarda contra isso. Passe adaptive=True (e opcionalmente adaptive_domain=...) na busca, e o Scrapling armazena uma impressão digital de cada elemento que você seleciona. Quando o DOM muda, ele realoca o elemento salvo por semelhança em vez de por um caminho exato, para que seus seletores continuem resolvendo através de mudanças de layout.

from scrapling.fetchers import DynamicFetcher

# Primeira execução: selecione normalmente; Scrapling lembra como era cada elemento.
page = DynamicFetcher.fetch(
    "https://quotes.toscrape.com/js/",
    cdp_url=session.browser_ws_endpoint,
    network_idle=True,
    adaptive=True,
    adaptive_domain="quotes.toscrape.com",
)
quotes = page.css("span.text::text")

# Mais tarde, depois que o site reorganiza sua marcação: reutilize a mesma chamada.
# Mesmo que "span.text" já não corresponda, o modo adaptativo realoca o elemento salvo.
page = DynamicFetcher.fetch(
    "https://quotes.toscrape.com/js/",
    cdp_url=session.browser_ws_endpoint,
    network_idle=True,
    adaptive=True,
    adaptive_domain="quotes.toscrape.com",
)
quotes = page.css("span.text::text")

Utilize seletores adaptativos em páginas que você scrape repetidamente e que passam por frequentes mudanças cosméticas — ele absorve a pequena oscilação do DOM, de modo que você só revisita seletores após um redesign genuíno.

Passo 5 — Ravê múltiplas páginas em uma única sessão na nuvem

A maioria dos trabalhos reais abrange mais de uma URL — listagens paginadas, resultados de pesquisa, árvores de categoria. Criar um novo navegador em nuvem para cada página descarta a sessão quente e paga o handshake da conexão novamente toda vez. O DynamicSession do Scrapling mantém uma única conexão com o navegador em nuvem Scrapeless aberta e busca cada página por meio dela, então cookies, a identidade residencial e o estado de navegação se mantêm durante toda a rastreação.

from scrapeless import Scrapeless
from scrapeless.types import ICreateBrowser
from scrapling.fetchers import DynamicSession

client = Scrapeless()
session = client.browser.create(ICreateBrowser(proxy_country="US", session_ttl=300))

rows = []
with DynamicSession(cdp_url=session.browser_ws_endpoint) as crawler:
    for n in range(1, 4):  # páginas 1..3
        url = "https://quotes.toscrape.com/js/" if n == 1 else f"https://quotes.toscrape.com/js/page/{n}/"
        page = crawler.fetch(url, network_idle=True)
        quotes = page.css("span.text::text")
        authors = page.css("small.author::text")
        rows += [{"quote": str(q), "author": str(a)} for q, a in zip(quotes, authors)]

print(len(rows), "linhas")  # dez linhas de citações por página se acumulam aqui

Cada página gera dez linhas de citações, acumuladas em rows ao longo de uma única sessão de navegador em nuvem reutilizada. network_idle=True espera cada página ser hidratada antes da extração; trate uma página curta ou vazia como um sinal de retentativa em vez do fim da listagem. Para uma raspagem de lista para detalhe, busque a listagem primeiro, colete as URLs de detalhe com page.css("a::attr(href)"), e então busque cada uma através do mesmo crawler — a sessão residencial e a impressão digital permanecem constantes durante toda a caminhada.

Passo 6 — Fortalecimento em produção

Mover de um script funcional para um trabalho confiável é principalmente sobre pressão de retrocesso e recuperação. Algumas regras carregam a maior parte do peso:

• Controle a concorrência. Mantenha ≤3 sessões de navegador na nuvem por host. Ultrapassar esse limite convida a limites de taxa e reinicializações de conexão, e o aumento marginal de throughput raramente justifica as falhas extras.
• Repetir erros de conexão transitórios com retrocesso. Erros de túnel e tempo limite, como ERR_TUNNEL_CONNECTION_FAILED, são transitórios por natureza. Capture-os, aguarde com retrocesso exponencial e tente novamente — não trate uma única falha de conexão como uma página morta.
• Rotacione a saída com ProxyRotator. O ProxyRotator do Scrapling alterna proxies entre solicitações para que você não pressione um alvo de um único IP; combine-o com o proxy residencial Scrapeless para trabalho com restrições geográficas.
• Reuse uma sessão entre etapas. Crie uma vez com session_ttl (por exemplo, 240 segundos) e passe o mesmo browser_ws_endpoint através de um fluxo de várias etapas — faça login, navegue, extraia — em vez de pagar para criar um novo navegador por solicitação.
• Trate campos ausentes como anuláveis. Páginas reais podem omitir classificações, autores ou preços em algumas linhas. Defina seletores ausentes como None em vez de afirmar que existem, para que um registro esparso não quebre a execução.

Obtenha sua chave de API no plano gratuito: Scrapeless

O que você recebe de volta

[
  {
    "quote": "O mundo como o criamos é um processo do nosso pensamento. Ele não pode ser mudado sem mudar nosso pensamento.",
    "author": "Albert Einstein"
  },
  {
    "quote": "São nossas escolhas, Harry, que mostram o que realmente somos, muito mais do que nossas habilidades.",
    "author": "J.K. Rowling"
  },
  {
    "quote": "Existem apenas duas maneiras de viver sua vida. Uma é como se nada fosse um milagre. A outra é como se tudo fosse um milagre.",
    "author": "Albert Einstein"
  }
]
// A forma reflete a extração da Etapa 3; os valores são amostras ilustrativas.

Algumas observações sinceras sobre a execução deste pipeline:

• Páginas renderizadas em JS precisam do navegador na nuvem. Um fetch HTTP simples de https://quotes.toscrape.com/js/ retorna 0 linhas; apenas o navegador na nuvem, acessado via cdp_url, executa o JavaScript para que Scrapling possa analisá-lo.
• network_idle=True aguarda pela hidratação. Ele espera até que a rede se estabilize, o que é importante em páginas que buscam seu conteúdo após a primeira pintura.
• Seletores adaptativos reduzem quebras, não verificações. Eles absorvem pequenas mudanças no DOM, mas após uma grande reestruturação, você ainda deve reexecutar a descoberta de seletores e confirmar a saída.
• Fixe proxy_country para páginas com restrições geográficas. Preços, disponibilidade e paredes de consentimento variam por região; definir proxy_country mantém os resultados consistentes com o local que você está direcionando.
• Páginas estáticas não precisam de nada disso. Se Fetcher.get já retorna os dados, use-o — eleve para o navegador na nuvem apenas quando o HTTP voltar vazio ou bloqueado.
• Erros de túnel transitórios e 5xx são recuperáveis. Um ERR_TUNNEL_CONNECTION_FAILED ou 500 ocasional é geralmente ruído de rede, não uma falha no seu código — tente novamente com retrocesso.

Conclusão: O fetcher mais leve primeiro, navegador na nuvem quando bloqueado

O pipeline se reduz a três movimentos. Escolha o fetcher mais leve que funcione — Fetcher.get para HTML estático. Eleve para o Scrapeless Scraping Browser passando session.browser_ws_endpoint para o cdp_url do Scrapling no momento em que uma página voltar vazia, bloqueada ou geograficamente restrita. Em seguida, analise com seletores adaptativos para que a extração sobreviva à próxima mudança de layout. Você só paga pelo navegador na nuvem quando realmente precisa — veja preços do Scrapeless para o que o nível gratuito cobre — e o restante do seu código permanece como Scrapling simples.

A partir daqui, o mesmo padrão cdp_url se conecta a sistemas maiores. Veja o guia LangChain + Scrapeless para integrar renderização em nuvem em um agente, e o tutorial do scraper Etsy para uma construção completa do site. Antes de enviar: exporte SCRAPELESS_API_KEY, fixe proxy_country para qualquer página com restrições geográficas, mantenha a concorrência em ≤3 sessões por host e trate campos ausentes como anuláveis.

FAQ

A raspagem de dados é legal?

Raspar dados públicos geralmente é permitido em muitas jurisdições, mas a lei não é uniforme. Revise os Termos de Serviço de cada site, evite coletar dados pessoais ou protegidos por direitos autorais que você não tem o direito de coletar e lembre-se de que as regras variam de acordo com a jurisdição. Quando em dúvida, consulte um advogado sobre seu caso específico.

Você precisa de um proxy?

Para qualquer coisa em grande escala, sim. A saída residencial reduz drasticamente os blocos em comparação com os IPs de datacenter, e é necessária para páginas que restringem conteúdo por região. Scrapeless fornece proxies residenciais em mais de 195 países — defina proxy_country ao criar uma sessão ou roteie através de um gateway proxy — para que você não precise buscar e rotacionar IPs você mesmo.

Quando você precisa do navegador em nuvem versus o Scrapling local?

Fique local quando Fetcher.get retornar os dados — esse é o caminho mais rápido. Aumente para o navegador em nuvem da Scrapeless via cdp_url quando a página tiver muito JavaScript do lado do cliente, for apresentada por um gerenciador de bots avançado ou for restrita geograficamente. O navegador em nuvem executa o JS e aplica anti-deteção e saída residencial que um fetch local não consegue igualar.

Por que você continua vendo ERR_TUNNEL_CONNECTION_FAILED ou erros 5xx?

Tente novamente. Esses são erros de conexão transitórios, não bugs no seu script. Envolva o fetch em um loop de repetição com retrocesso exponencial e um limite sensato; a maioria deles se resolve na segunda ou terceira tentativa.

Meus seletores quebraram após uma reformulação do site. Como consertá-los?

Ative seletores adaptativos (adaptive=True com adaptive_domain=...) para que o Scrapling realoque elementos salvos através de pequenas alterações no DOM. Após uma grande reformulação, execute novamente a descoberta de seletores para confirmar a nova marcação e, em seguida, deixe o modo adaptativo manter a linha novamente.

Existem limites de concorrência que você deve respeitar?

Mantenha em ≤3 sessões de navegador em nuvem por host. Além disso, você troca um pouco de largura de banda por muito limitador de taxa e reinicializações de conexão. Use concorrência limitada e uma fila em vez de disparar todos os pedidos de uma vez.

Scrapling envia seu próprio MCP (pip install "scrapling[ai]") — como isso se relaciona com isso?

Você pode sobrepor ambos. O MCP do Scrapling dá a um agente de IA controle direto sobre a biblioteca local; o servidor MCP do Scrapeless oferece a esse agente renderização em nuvem com anti-deteção e proxies residenciais. Use-os juntos ou escolha o que se adequa à sua pilha. Este guia segue o caminho da biblioteca — Scrapling controlando o navegador em nuvem da Scrapeless através de cdp_url — o que mantém a integração a um único argumento e sem servidor extra para executar.

Pronto para construir seu pipeline de dados alimentado por IA?

Junte-se à nossa comunidade para reivindicar um plano gratuito e conectar-se com desenvolvedores que estão construindo pipelines de dados Scrapling + Scrapeless: Discord · Telegram.

Inscreva-se no Scrapeless para um tempo de execução gratuito do Navegador de Scraping e adapte os padrões acima às páginas e regiões que seu pipeline precisa. Referência completa em docs.scrapeless.com.