Neste tutorial, você aprenderá como usar a biblioteca Python cloudscraper para contornar a detecção de bots do Cloudflare, lidar com erros comuns e explorar soluções alternativas de scraping para as proteções anti-bot mais robustas.
Como usar o cloudscraper em Python
Neste tutorial, você tentará extrair dados de um site protegido pelo Cloudflare com e sem o cloudscraper. Para fazer isso, você usará os pacotes Beautiful Soup eRequests. Se você não estiver familiarizado com esses pacotes, consulteeste guia de Scraping de dados em Pythonpara saber mais.
Para começar, instale os pacotes necessários executando o seguinte comando pip:
pip install tqdm==4.66.5 requests==2.32.3 beautifulsoup4==4.12.3
Para facilitar o acompanhamento deste tutorial, foi criado o seguinte Scraper para extrair metadados de artigos de notícias publicados em um determinado dia nosite ChannelsTV:
import requests
from bs4 import BeautifulSoup
from datetime import datetime
from tqdm.auto import tqdm
def extract_article_data(article_source, headers):
response = requests.get(article_source, headers=headers)
if response.status_code != 200:
return None
soup = BeautifulSoup(response.content, 'html.parser')
title = soup.find(class_="post-title display-3").text.strip()
date = soup.find(class_="post-meta_time").text.strip()
date_object = datetime.strptime(date, 'Updated %B %d, %Y').date()
categories = [category.text.strip() for category in soup.find('nav', {"aria-label": "breadcrumb"}).find_all('li')]
tags = [tag.text.strip() for tag in soup.find("div", class_="tags").find_all("a")]
article_data = {
'date': date_object,
'title': title,
'link': article_source,
'tags': tags,
'categories': categories
}
return article_data
def process_page(articles, headers):
page_data = []
para artigo em tqdm(artigos):
url = artigo.find('a', href=True).get('href')
se "https://" não estiver em url:
continue
dados_do_artigo = extrair_dados_do_artigo(url, cabeçalhos)
se dados_do_artigo:
dados_da_página.append(article_data)
return page_data
def scrape_articles_per_day(base_url, headers):
day_data = []
page = 1
while True:
page_url = f"{base_url}/page/{page}"
response = requests.get(page_url, headers=headers)
if not response or response.status_code != 200:
break
soup = BeautifulSoup(response.content, 'html.parser')
articles = soup.find_all('article')
if not articles:
break
page_data = process_page(articles, headers)
day_data.extend(page_data)
página += 1
retornar dados_do_dia
cabeçalhos = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36',
}
URL = "https://www.channelstv.com/2024/08/01/"
scraped_articles = scrape_articles_per_day(URL, headers)
print(f"{len(scraped_articles)} artigos foram coletados.")
print("Amostras:")
print(scraped_articles[:2])
Neste código, três funções são definidas para facilitar o processo de extração. A primeira, chamada extrair_dados_do_artigo, carrega os dados de um artigo individual e extrai metadados, como data de publicação, título, tags e categorias, para um dicionário Python, que é então retornado. As etapas de carregamento e extração são implementadas usando as bibliotecas Python Requests e Beautiful Soup.
A segunda função, process_page, obtém o link para todos os artigos em uma página específica e chama a função extract_article_data para extrair os dados neles contidos e armazena cada dicionário de metadados em uma lista, que é então retornada. A última função, chamada scrape_articles_per_day, usa um loop while para incrementar o número da página e extrai os dados do artigo em cada página até chegar a uma página que não existe.
Em seguida, você define a URL a ser raspada e especifica a data a ser filtrada como 1º de agosto de 2024 e uma variável de cabeçalhos contendo um agente de usuário de amostra. Você chama a função scrape_articles_per_day e passa as variáveis URL e cabeçalhos. Em seguida, você imprime o número de artigos raspados e os dois primeiros resultados.
Idealmente, esse Scraper funcionaria, mas não funciona porque o site ChannelsTV usa o Cloudflare para impedir que você acesse o conteúdo de suas páginas da web por meio das solicitações diretas implementadas nas funçõesextract_article_dataescrape_articles_per_day.
Quando você tenta executar este script, sua saída fica assim:
0 artigos foram coletados.
Amostras:
[]
Incorpore o cloudscraper
Anteriormente, quando você pretendia extrair metadados específicos de um artigo, nada era retornado, graças à proteção do Cloudflare. Nesta seção, você instalará e usará o cloudscraper para contornar esse problema.
Para começar, instale a biblioteca cloudscraper executando o seguinte comando pip:
pip install cloudscraper==1.2.71
Em seguida, importe o pacote e defina uma função fetch_html_content assim:
import cloudscraper
def fetch_html_content(url, headers):
try:
scraper = cloudscraper.create_scraper()
response = scraper.get(url, headers=headers)
if response.status_code == 200:
return response
else:
print(f"Falha ao buscar URL: {url}. Código de status: {response.status_code}")
return None
except Exception as e:
print(f"Ocorreu um erro ao buscar URL: {url}. Erro: {str(e)}")
return None
Esta função recebe a URL a ser raspada e os cabeçalhos da solicitação como parâmetros de entrada e retorna um objeto de resposta ou None. Dentro da função, você define um bloco try-except. No bloco try, você cria um Scraper usando o método cloudscraper.create_scraper. Em seguida, você chama o método scraper.get e passa as variáveis url e headers. Se o código de status da sua resposta for 200, você retorna a resposta. Caso contrário, você imprime uma mensagem de erro e retorna None. Da mesma forma, se ocorrer um erro no bloco try, o bloco except é acionado, no qual uma mensagem apropriada é impressa e None é retornado.
Em seguida, você substitui todas as chamadas requests.get no seu script por esta função fetch_html_content. Inicialmente, faça essa substituição na sua função extract_article_data desta forma:
def extract_article_data(article_source, headers):
response = fetch_html_content(article_source, headers)
Em seguida, substitua a chamada requests.get na sua função scrape_articles_per_day desta forma:
def scrape_articles_per_day(base_url, headers):
day_data = []
page = 1
while True:
page_url = f"{base_url}/page/{page}"
response = fetch_html_content(page_url, headers)
Ao definir essa função, a biblioteca cloudscraper pode ajudá-lo a contornar as restrições do Cloudflare.
Ao executar o código, sua saída ficará assim:
Falha ao buscar URL: https://www.channelstv.com/2024/08/01//page/5. Código de status: 404
55 artigos foram coletados.
Amostras:
[{'date': datetime.date(2024, 8, 1),
'title': 'Resiliência, gás lacrimogêneo, saques e toque de recolher durante os protestos #EndBadGovernance',
'link': 'https://www.channelstv.com/2024/08/01/tear-gas-resilience-looting-curfew-as-endbadgovernance-protests-hold/',
'tags': ['Eagle Square', 'Fome', 'Saques', 'MKO Abiola Park', 'violência'],
'categories': ['Headlines']},
{'date': datetime.date(2024, 8, 1),
'title': 'Mãe de artista russo libertado em troca de prisioneiros espera para 'abraçá-la',
'link': 'https://www.channelstv.com/2024/08/01/mother-of-russian-artist-freed-in-prisoner-swap-waiting-to-hug-her/',
'tags': ['Troca de prisioneiros', 'Rússia'],
'categories': ['Notícias internacionais']}]
Recursos adicionais do Cloudscraper
Como você pode ver, o Cloudscraper pode ajudá-lo a contornar a proteção IUAM da Cloudflare, mas ele também possui outros recursos que merecem destaque.
Usando proxies
Os proxies funcionam como servidores intermediários entre o seu computador e os sites de destino, permitindo que você fique mais anônimo enquanto navega na internet. Suas solicitações são encaminhadas por eles para que os sites de destino, como os sites protegidos pela Cloudflare, vejam o servidor Proxy como a fonte do tráfego e não o seu dispositivo.
Com o cloudscraper, você pode definir Proxies e passá-los para o seu objeto cloudscraper já criado desta forma:
scraper = cloudscraper.create_scraper()
Proxy = {
'http': 'http://your-proxy-ip:port',
'https': 'https://your-proxy-ip:port'
}
response = scraper.get(URL, proxies=Proxy)
Aqui, você define um objeto Scraper com valores padrão. Em seguida, você define um dicionário Proxy com proxies http e https. Por fim, você passa o objeto dicionário Proxy para o método scraper.get, como faria com um método request.get normal.
Alterando o agente do usuário e o interpretador JavaScript
Embora você tenha especificado diretamente um agente do usuário no script anterior, a biblioteca cloudscraper também pode gerar automaticamente agentes do usuário. Isso reduz as configurações manuais necessárias durante a criação de scripts e permite imitar usuários reais com diferentes identidades de navegador. Isso é feito aleatoriamente, mas você também pode selecionar o tipo de agentes de usuário a partir dos quais ele faz a amostragem, passando um parâmetro do navegador para o método cloudscraper.create_scraper. Esse parâmetro do navegador contém um dicionário que armazena valores de string para o navegador e a plataforma e valores booleanos para desktop e celular.
O cloudscraper também permite que você especifique o interpretador e o mecanismo JavaScript que você usa com seu Scraper. O padrão é um solucionador nativo criado pela equipe do cloudscraper. Outras opções disponíveis são Node.js, Js2Py, ChakraCore e v8eval.
Aqui está um trecho de código de exemplo mostrando as especificações de um interpretador e navegador:
Scraper = cloudscraper.create_scraper(
interpreter="nodejs",
browser={
"browser": "chrome",
"platform": "ios",
"desktop": False,
}
)
Aqui, você define o interpretador como "nodejs" e passa um dicionário para o parâmetro do navegador. Dentro desse dicionário, o navegador é definido como Chrome e a plataforma é definida como "ios". O parâmetro desktop é definido como False, o que implica que o navegador é executado em dispositivos móveis, já que os valores mobile e desktop são definidos como True por padrão. Nesse caso, a Cloudflare seleciona agentes de usuário iOS móveis executados no navegador Chrome.
Lidando com CAPTCHAs
Os CAPTCHAssão projetados para diferenciar humanos e bots e, muitas vezes, podem impedir que sua página da web de destino seja carregada quando você está fazendo scraping de dados. Um dos benefícios do cloudscraper é que ele oferece suporte a alguns solucionadores de CAPTCHA de terceiros, dedicados a reCAPTCHA, hCaptcha e muito mais. Se você tiver outros solucionadores de CAPTCHA de terceiros nos quais esteja interessado, pode enviar sua sugestão à equipe do cloudscraper por meio de tickets de suporte do GitHub.
O trecho a seguir mostra como modificar seu Scraper para lidar com CAPTCHA:
Scraper = cloudscraper.create_scraper(
captcha={
'provider': 'capsolver',
'api_key': 'your_capsolver_api_key'
}
)
Neste código, você especifica seu provedor CAPTCHA como Capsolver e sua chave API Capsolver. Ambos os valores são armazenados em um dicionário e passados para o parâmetro CAPTCHA no método cloudscraper.create_scraper.
Erros comuns do cloudscraper
Embora o cloudscraper seja uma maneira fácil de contornar as restrições do Cloudflare, você pode encontrar alguns erros ao começar a usá-lo. A seguir estão alguns dos erros mais comuns (e soluções) que você pode encontrar.
Módulo não encontrado
O erro de módulo não encontrado é um erro comum no Python que ocorre quando você tenta importar ou usar uma biblioteca que não existe no seu ambiente Python.
Ao trabalhar em Python, você opera dentro de um ambiente, e apenas as bibliotecas instaladas nesse ambiente ativo são acessíveis pelo seu script ou notebook. O erro “módulo não encontrado” implica que você não ativou o ambiente (virtual) relevante ou não instalou o pacote no seu ambiente.
Para ativar seu ambiente virtual no Windows, execute o seguinte comando:
.<venv-name>Scriptsactivate.bat
Se você estiver trabalhando com Linux ou macOS, pode usar o seguinte comando:
source <venv-name>/bin/activate
Se o pacote não estiver instalado, instale-o executando o seguinte comando:
pip install cloudscraper
O cloudscraper não consegue ignorar a versão mais recente do Cloudflare
O erro “O cloudscraper não consegue ignorar a versão mais recente do Cloudflare ” ocorre quando você tenta usar uma versão do cloudscraper projetada para ignorar uma versão mais antiga do Cloudflare. Isso é um problema porque as versões mais recentes do Cloudflare podem vir com alterações que restringem as versões mais antigas do cloudscraper até que a biblioteca Python seja atualizada.
Se você estiver executando uma versão mais antiga do cloudscraper, é melhor atualizar seu pacote com o seguinte comando:
pip install -U cloudscraper
Nos casos em que você já estiver usando a versão mais recente do cloudscraper, talvez seja necessário aguardar uma atualização ou encontrar uma solução alternativa que funcione.
Uma alternativa ao cloudscraper
Se, após implementar o que você aprendeu aqui, ainda tiver dificuldade para contornar a proteção do Cloudflare, considere usar o Bright Data.
O Bright Data possui uma das maiores redes de proxy, incluindo proxiesde data center, ISP, móveis e residenciais. Com esses proxies servindo como intermediários, você pode evitar o bloqueio de IP, aumentar o desempenho, contornar restrições geográficas e proteger sua privacidade.
Para contornar a proteção do Cloudflare usando o Bright Data, tudo o que você precisa fazer é criar uma conta, configurá-la e obter suas credenciais de API. Em seguida, você pode usar essas credenciais para acessar os dados em sua URL de destino desta forma:
import requests
host = 'brd.superproxy.io'
port = 22225
username = 'brd-customer-<CUSTOMER_ID>-zone-<ZONE_NAME>'
password = '<ZONE_PASSWORD>'
proxy_url = f'http://{username}:{password}@{host}:{port}'
proxies = {
'http': proxy_url,
'https': proxy_url
}
response = requests.get(URL, proxies=proxies)
Aqui, você faz uma solicitação GET com a biblioteca Python Requests e passa os Proxies através do parâmetro proxies. Os Proxies criados usam seu nome de usuário, senha, host e número de porta da Bright Data. Seu nome de usuário, em particular, é definido com base no seu ID de cliente da Bright Data e no nome da zona — todos esses dados podem ser recuperados da sua conta.
Conclusão
Neste tutorial, você aprendeu como usar a biblioteca cloudscraper em Python para extrair dados de sites protegidos pelo Cloudflare. Você também aprendeu sobre alguns erros comuns que pode encontrar e como contorná-los. Embora o cloudscraper possa ser uma ótima solução para contornar o IUAM do Cloudflare, como qualquer tecnologia gratuita, ele tem suas limitações. É por isso que você também aprendeu a usar a impressionante rede de Proxiesda Bright Dataeo Web Unlockerpara acessar sites protegidos pelo Cloudflare.
A Bright Data fornece ferramentas automatizadas que permitem que você acesse dados na Internet sem nenhuma restrição. Você também pode usar sua grande rede de Proxies para reduzir o número de solicitações com falha, caso a automação não seja seu objetivo.
Pronto para levar o Scraping de dados da web para o próximo nível? Descubra como nossos proxies premium e serviços especializados de coleta de dados da web podem facilmente contornar até mesmo as proteções contra bots mais difíceis. Comece com um teste grátis hoje mesmo!
