--- title: "Conheça o SDK Python da Bright Data: Faça Scraping, Pesquise e Obtenha Dados da Web" slug: bright-data-python-sdk date: 2026-10-18T12:40:06+00:00 modified: 2026-10-18T12:40:08+00:00 permalink: https://brightdata.com.br/blog/ai/bright-data-python-sdk type: blog --- [ Blog ](https://brightdata.com.br/blog "Blog") / [AI](https://brightdata.com.br/blog/ai) [AI](https://brightdata.com.br/blog/ai) # Conheça o SDK Python da Bright Data: Faça Scraping, Pesquise e Obtenha Dados da Web Aprenda a usar o SDK Python da Bright Data para fazer scraping de sites, pesquisar no Google e Bing, exportar dados e executar tarefas simultaneamente em Python. 22 min de leitura [ ![Antonello Zanini](https://media.brightdata.com.br/2022/12/Antonello-Zanini-2-50x50.jpg) ](https://brightdata.com/blog/authors/antonello-zanini) [Antonello Zanini Technical Writer ](https://brightdata.com/blog/authors/antonello-zanini) ![Bright Data Python SDK](https://media.brightdata.com.br/2026/10/Bright-Data-Python-SDK.png) Neste guia, você aprenderá: - O que é o SDK Python da Bright Data. - Como ele funciona internamente, incluindo como funciona a autenticação. - O que ele oferece, incluindo modos síncronos e assíncronos, principais recursos e métodos. - Como instalar o SDK e executar suas primeiras solicitações passo a passo. - Tópicos avançados como polling, scraping simultâneo e mais. - Casos de uso reais, desde comparar resultados de mecanismos de busca até fazer parsing de páginas web com BeautifulSoup para extração manual de dados. Vamos começar! ## O Que É o SDK Python da Bright Data? O [SDK Python da Bright Data](https://docs.brightdata.com/api-reference/SDK) é uma biblioteca Python projetada para simplificar as interações com os [produtos da Bright Data](/products). O SDK está disponível através do pacote PyPI [`brightdata-sdk`](https://pypi.org/project/brightdata-sdk/). Ele fornece uma interface unificada para fazer scraping de sites, recuperar resultados de mecanismos de busca, acessar conjuntos de dados prontos e trabalhar com soluções da Bright Data. Em detalhes, o SDK Python inclui integrações prontas para uso com mais de 100 [Scraper APIs da Bright Data](/products/web-scraper), ajudando você a acessar dados públicos, estruturados e atualizados de plataformas como Amazon, LinkedIn, Instagram, TikTok e muitas outras. **Nota**: Se você preferir trabalhar no terminal, o [CLI da Bright Data](https://docs.brightdata.com/products/cli/overview) oferece muitas das mesmas capacidades através de comandos de linha de comando. Saiba como usar o [CLI da Bright Data com agentes de IA](/blog/ai/bright-data-cli-with-top-coding-agents). **Leitura adicional**: - [*Documentação do SDK Python da Bright Data*](https://docs.brightdata.com/api-reference/SDK) - [*Repositório oficial do SDK Python da Bright Data*](https://github.com/brightdata/sdk-python) ## Como Funciona o SDK Python Internamente, o SDK envolve as APIs da Bright Data em classes Python. Dessa forma, você pode interagir com os serviços da Bright Data sem construir manualmente solicitações HTTP, chamar endpoints de API e fazer parsing de respostas. Em vez disso, você só precisa chamar métodos Python amigáveis para desenvolvedores. A biblioteca é totalmente tipada e bem documentada, facilitando a exploração de suas capacidades em seu IDE. ![Observe o autocompletar do IDE, sugestões de uso e documentação de métodos](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791816660506_image.png)Você obtém autocompletar, dicas de tipo e exemplos de uso para ajudar a entender os parâmetros disponíveis e como usar cada método. Os objetos retornados também são tipados, permitindo que você acesse facilmente os campos de resposta. A autenticação é feita através do [token de API da Bright Data](https://docs.brightdata.com/api-reference/authentication#how-do-i-generate-a-new-api-key) ou, se você já se autenticou via CLI da Bright Data, das credenciais salvas por [`brightdata login`](https://docs.brightdata.com/products/cli/commands#brightdata-login). Observe que, se sua conta Bright Data não tiver as APIs necessárias que o SDK chama internamente, a biblioteca as configura automaticamente para você. ## O Que o SDK Oferece Agora que o modelo central está claro, o próximo passo é explorar o que o SDK Python traz para a mesa. ### Principais Recursos O SDK Python da Bright Data cobre um amplo conjunto de capacidades, incluindo: - **Scraping de dados**: Faça scraping de URLs individuais ou múltiplas simultaneamente e recupere o conteúdo do site com código mínimo. - **Resultados de mecanismos de busca**: Recupere resultados do Google, Bing e Yandex, com suporte para consultas específicas de localização e pesquisas em lote. - **Scrapers específicos de plataforma**: Extraia dados estruturados de Amazon, LinkedIn, Instagram, Facebook, TikTok, YouTube, Reddit, Pinterest, ChatGPT, Perplexity e outras plataformas. - **Pesquisa específica de plataforma**: Descubra perfis, vagas, publicações e outros conteúdos usando parâmetros de pesquisa em vez de apenas URLs. - [**Integração com o Scraper Studio**](https://docs.brightdata.com/products/scraper-studio/overview): Execute scrapers personalizados, dispare tarefas de coleta, monitore seu status e recupere resultados. - **Métodos e respostas tipados**: Beneficie-se de dicas de tipo, autocompletar do IDE, sugestões de parâmetros e objetos de resposta estruturados para facilitar o desenvolvimento. - **Gerenciamento de conta e API**: Verifique a conectividade, inspecione informações da conta e uso, liste APIs e gerencie configurações de API. - **Exportação de dados**: Salve os resultados de conjuntos de dados da web coletados em formatos JSON, CSV ou JSONL. ### Principais Métodos do SDK Comece instalando o SDK Python da Bright Data: ```none pip install brightdata-sdk ``` Uma vez instalado, importe o SDK e você terá acesso a vários métodos, como: **Método****O que faz****Produto Bright Data**`client.scrape_url(url)`Busca o conteúdo de uma URL ou de uma lista de URLs, [contornando qualquer sistema anti-bot](https://docs.brightdata.com/concepts/how-bright-data-handles-blocking)[Unlocker API](/products/web-unlocker)`client.search.google(query=...)`Executa uma pesquisa no Google e retorna resultados orgânicos processados[API SERP](/products/serp-api)`client.search.bing(query=...)`Executa uma pesquisa no Bing e retorna resultados orgânicos processadosAPI SERP (consulte o [guia de migração para a Bing Web Search API](https://docs.brightdata.com/products/serp-api/parsed-json-results/bing-to-bright-data-serp-migration-guide))`client.scrape..(url=...)`Extrai dados estruturados de uma plataforma alvo, como `client.scrape.amazon.products`Scraper APIs`client.search.linkedin.jobs(...)`Pesquisa em uma plataforma por parâmetros em vez de URLsScraper APIs específicas`client.datasets.(filter=...)`Solicita um snapshot filtrado de um conjunto de dados pré-coletado[Dataset APIs](https://docs.brightdata.com/api-reference/marketplace-dataset-api/filter-dataset)`client.scraper_studio.run(collector=..., input=...)`Dispara um coletor de scraping de dados personalizado e retorna seus registros[Scraper Studio](/products/web-scraper/studio)`client.browser.get_connect_url()`Constrói o endpoint CDP para conectar Playwright ou Puppeteer a um navegador na nuvem[Browser API](/products/scraping-browser)`client.list_zones()`Lista as zonas disponíveis em sua contaNenhum### Clientes Síncronos e Assíncronos O SDK fornece dois clientes com os mesmos nomes de método, mas modelos de execução diferentes: - `BrightDataClient`: O cliente assíncrono, projetado para aplicações que usam `asyncio` e precisam lidar com cargas de trabalho de alta concorrência. - `SyncBrightDataClient`: O cliente síncrono, ideal para scripts simples e solicitações sequenciais diretas. É assim que se chama `scrape_url()` usando `SyncBrightDataClient`: ```none from brightdata import SyncBrightDataClient with SyncBrightDataClient() as client: result = client.scrape_url("https://example.com") print(result.data) ``` De forma equivalente, com `BrightDataClient`, você precisa usar [`async with` para gerenciar o cliente e `await` para chamar métodos assíncronos](https://docs.python.org/3/howto/a-conceptual-overview-of-asyncio.html): ```none import asyncio from brightdata import BrightDataClient async def main(): async with BrightDataClient() as client: result = await client.scrape_url("https://example.com") print(result.data) asyncio.run(main()) ``` Ambos os exemplos retornam o HTML da página alvo em `result.data`: ![O HTML da página alvo example.com](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791817848730_image.png)Lembre-se de que, embora `BrightDataClient` seja assíncrono, `scrape_url()` usa `mode="sync"` por padrão. Isso significa que a chamada espera até que o resultado do scraping esteja disponível antes de retornar. Para usar `scrape_url()` em modo puramente assíncrono, passe `mode="async"`: ```none import asyncio from brightdata import BrightDataClient async def main(): async with BrightDataClient() as client: result = await client.scrape_url( url="https://example.com", mode="async", poll_interval=5, # Verifica a cada 5 segundos poll_timeout=180, # Permite até 3 minutos ) print(result.data) asyncio.run(main()) ``` No modo de scraping assíncrono, o SDK: 1. Envia uma solicitação ao endpoint da Web Unlocker API. 2. Recebe um `response_id` que identifica a solicitação pendente. 3. Faz polling no endpoint de resultados usando esse ID até que os dados estejam prontos ou o tempo limite seja atingido. 4. Retorna os dados do resultado quando ficam disponíveis. Para mais informações sobre como escolher entre os modos de solicitação síncrono e assíncrono, consulte a [documentação Sync vs. Async](https://docs.brightdata.com/concepts/sync-vs-async). **Notas**: - Os parâmetros `poll_interval` e `poll_timeout` controlam com que frequência o SDK verifica os resultados e por quanto tempo espera. Para `scrape_url()`, seus padrões são `2` segundos e `30` segundos, respectivamente. - As solicitações assíncronas do Web Unlocker podem levar cerca de dois minutos para serem concluídas, então defina `poll_timeout` adequadamente. ### Configuração Automática das APIs da Bright Data As solicitações feitas através do SDK dependem das APIs da Bright Data configuradas em sua conta: ![As APIs da Bright Data configuradas em sua conta](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791821313295_image.png)Por padrão, tanto `SyncBrightDataClient` quanto `BrightDataClient` definem `auto_create_zones=True`. Essa opção controla se o SDK cria as zonas de API necessárias caso ainda não existam. Quando a criação automática está habilitada, o SDK garante que as seguintes zonas estejam disponíveis antes de fazer a primeira solicitação de API: - `sdk_unlocker` para a Web Unlocker API - `sdk_serp` para a API SERP ![Observe as duas APIs criadas pelo SDK](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791822018286_image.png)Se preferir gerenciar suas zonas de API você mesmo, defina `auto_create_zones=False`. O SDK não criará as APIs, então você deve fornecer os nomes de suas zonas existentes através de `web_unlocker_zone` e `serp_zone`. Para usar uma zona de Unlocker API personalizada, escreva: ```none import asyncio from brightdata import BrightDataClient async def main(): async with BrightDataClient( auto_create_zones=False, web_unlocker_zone="web_unlocker", # Substitua pela sua zona personalizada de Unlocker API ) as client: result = await client.scrape_url("https://example.com") print(result.data) asyncio.run(main()) ``` ## Começando com o SDK Python da Bright Data: Guia Passo a Passo Com os conceitos claros, é hora de instalar, autenticar e testar os métodos do SDK. ### Pré-requisitos Antes de começar, certifique-se de ter: - [Python 3.9+](https://www.python.org/downloads/) instalado localmente. - Uma [conta Bright Data](/?hs_signup=1). - Um token de API da Bright Data, que você pode gerar no [Painel de Controle da Bright Data](/cp/setting/users). ### Passo #1: Instale o SDK Instale o SDK Python da Bright Data via pip com: ```none pip install brightdata-sdk ``` Se você já tiver uma versão mais antiga instalada, atualize-a com: ```none pip install -U brightdata-sdk ``` **Importante:** Este guia se refere a versões do SDK posteriores a `2.5.0`. Muito bem! Avance para a autenticação agora mesmo. ### Passo #2: Autentique-se com Seu Token de API da Bright Data O SDK Python da Bright Data lê a variável de ambiente `BRIGHTDATA_API_KEY` para autenticar solicitações às APIs da Bright Data. No Linux ou macOS, defina a variável de ambiente necessária para sua chave de API da Bright Data com: ```none export BRIGHTDATA_API_KEY="" ``` No Windows PowerShell, execute: ```none $Env:BRIGHTDATA_API_KEY = "" ``` Uma vez definida a variável de ambiente, o cliente assíncrono padrão captura sua chave de API automaticamente: ```none from brightdata import BrightDataClient async with BrightDataClient() as client: # ... ``` Você também pode passar sua chave de API diretamente ao criar o cliente através do argumento `token`: ```none from brightdata import BrightDataClient async with BrightDataClient(token="") as client: # Faça solicitações de API aqui ... ``` Passar o token diretamente pode ser útil para testes rápidos. No entanto, evite codificar chaves de API diretamente em arquivos de código-fonte. O SDK verifica as credenciais na seguinte ordem: 1. O argumento `token` passado para `BrightDataClient` ou `SyncBrightDataClient`. 2. A variável de ambiente `BRIGHTDATA_API_TOKEN`. 3. A variável de ambiente `BRIGHTDATA_API_KEY`. 4. Credenciais salvas pelo CLI da Bright Data usando `brightdata login`, se disponíveis. Tudo pronto! Agora você pode usar o SDK Python para fazer scraping de páginas web, recuperar resultados de pesquisa e acessar outras APIs da Bright Data. ### Passo #3: Execute Sua Primeira Tarefa de Coleta de Dados da Web Com o SDK instalado e autenticado, execute seu primeiro scraping. Suponha que você queira coletar dados estruturados de um [perfil específico do LinkedIn](https://es.linkedin.com/in/antonello-zanini). Para essa tarefa, você pode usar a [Bright Data LinkedIn Profiles Scraper API](/products/web-scraper/linkedin/profiles), disponível através do método `client.scrape.linkedin.profiles()`. Isso retorna os dados do perfil em um objeto estruturado: ```none import asyncio from brightdata import BrightDataClient from pprint import pprint async def main(): async with BrightDataClient() as client: result = await client.scrape.linkedin.profiles( url="https://linkedin.com/in/antonello-zanini" # Perfil do LinkedIn alvo para scraping ) print(f"Sucesso: {result.success}") print("\nDados do perfil coletados:") pprint(result.data, indent=2, sort_dicts=False) asyncio.run(main()) ``` O resultado será: ![Os dados estruturados do perfil do LinkedIn retornados pelo script](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791835516140_image.png)Observe como o método retorna dados públicos, estruturados e recém-coletados do perfil do LinkedIn fornecido, exatamente como esperado: ![O perfil do LinkedIn alvo](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791835586169_image.png)Missão cumprida! ## Uso Avançado Agora que você está confortável com o básico, está pronto para explorar tópicos mais avançados. ### Mecanismo de Polling Algumas tarefas de scraping levam mais do que alguns segundos, e você pode querer ter controle sobre o que está acontecendo enquanto elas são executadas. Para essas situações, a Bright Data permite [executar Scraper APIs como tarefas assíncronas](https://docs.brightdata.com/api-reference/rest-api/scraper/asynchronous-requests). A ideia é disparar o scraping e receber uma tarefa imediatamente de volta. Depois, você verifica seu status, espera que ela termine e busca os resultados quando foram produzidos. Normalmente, isso exigiria uma lógica de polling personalizada, mas o SDK já fornece métodos que simplificam o processo. O script a seguir realiza scraping assíncrono para um perfil do LinkedIn: ```none import asyncio from brightdata import BrightDataClient async def main(): async with BrightDataClient() as client: # Inicia a tarefa de scraping e retorna uma tarefa imediatamente job = await client.scrape.linkedin.profiles_trigger( url="https://es.linkedin.com/in/antonello-zanini" ) print(f"Tarefa disparada: {job.snapshot_id}") # O ID que identifica essa tarefa # Verifica o estado atual da tarefa, como "running" ou "ready" status = await job.status() print(f"Status: {status}") # Faz polling na tarefa até que esteja "ready" await job.wait(timeout=180, verbose=True) # Baixa os registros assim que a tarefa estiver pronta data = await job.fetch() print(f"Obtidos {len(data) if isinstance(data, list) else 1} registros") asyncio.run(main()) ``` Abaixo está o que cada método do SDK faz: 1. `profiles_trigger()` inicia a tarefa de scraping e retorna um objeto de tarefa sem esperar que o scraping termine. 2. `job.status()` verifica o status atual da tarefa. 3. `job.wait()` faz polling no status da tarefa em intervalos regulares até que a tarefa esteja pronta ou o tempo limite seja atingido. Por padrão, verifica o status a cada 10 segundos. Se o tempo limite for atingido primeiro, levanta um [`TimeoutError`](https://docs.python.org/3/builtins/exceptions.html#TimeoutError). 4. `job.fetch()` recupera os registros coletados assim que a tarefa estiver pronta. Definir `verbose=True` imprime cada verificação de status, para que você possa acompanhar o progresso da tarefa: ![Os logs produzidos pelo script anterior](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791832933568_image.png)Se você não precisar gerenciar cada etapa sozinho, `to_result()` combina esperar, buscar e encapsular os dados em um objeto de resultado: ```none import asyncio from brightdata import BrightDataClient from pprint import pprint async def main(): async with BrightDataClient() as client: # Inicia a tarefa de scraping e retorna uma tarefa imediatamente job = await client.scrape.linkedin.profiles_trigger( url="https://es.linkedin.com/in/antonello-zanini" ) print(f"Tarefa disparada: {job.snapshot_id}") # O ID que identifica essa tarefa result = await job.to_result(timeout=180) # Faz polling, busca e obtém os dados print(f"Sucesso: {result.success}") print("\nDados do perfil coletados:") pprint(result.data, indent=2, sort_dicts=False) asyncio.run(main()) ``` Isso retorna o mesmo objeto de resultado que o método `scrape.linkedin.profiles()` mostrado anteriormente neste tutorial. Se precisar de mais controle sobre o polling, considere implementar seu próprio loop chamando repetidamente `job.status()` e ajustando sua lógica com base no status retornado (ou seja, `"running"`, `"ready"`, ou `"error"`). ### Fazer Scraping de Várias Páginas Simultaneamente Quando você precisa buscar várias páginas, passe uma lista de URLs para o método de scraping do SDK Python da Bright Data. O SDK as busca simultaneamente e retorna um objeto de resultado por URL. Dê uma olhada no exemplo abaixo: ```none import asyncio from brightdata import BrightDataClient urls = [ "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html", "https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html", "https://books.toscrape.com/catalogue/soumission_998/index.html", ] async def main(): async with BrightDataClient() as client: # Busca todas as URLs simultaneamente results = await client.scrape_url(urls) # Cada item em results é um objeto de resultado para uma URL for i, r in enumerate(results): if r.success: # Ignora as URLs que falharam print(f"URL: {urls[i]}") print(f"{r.data[:500]}...") # Primeiros 500 caracteres do HTML bruto print("-" * 80 + "\n") asyncio.run(main()) ``` O script imprime uma linha para cada URL bem-sucedida, mostrando os primeiros 500 caracteres de seu HTML bruto: ![Observe as três páginas HTML diferentes coletadas](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791833920080_image.png)A mesma ideia se aplica aos scrapers de plataforma. O script a seguir coleta dois perfis do LinkedIn ao mesmo tempo: ```none import asyncio from brightdata import BrightDataClient PROFILE_URLS = [ "https://es.linkedin.com/in/antonello-zanini", "https://it.linkedin.com/in/federico-trotta", ] async def main(): async with BrightDataClient() as client: linkedin = client.scrape.linkedin # Dispara todos os perfis primeiro, para que todas as tarefas comecem antes de você esperar por qualquer uma delas job = await linkedin.profiles_trigger(url=PROFILE_URLS) # Faz polling na tarefa até que esteja "ready" await job.wait(timeout=180, verbose=True) # Baixa os registros assim que a tarefa estiver pronta data = await job.fetch() print(f"Obtidos {len(data) if isinstance(data, list) else 1} registros") asyncio.run(main()) ``` A saída será um conjunto de dados contendo dois perfis, coletados simultaneamente: ![Observe que o script coletou dois perfis do LinkedIn ao mesmo tempo](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791834093109_image.png)### Exportar Dados Recuperados O SDK pode salvar dois tipos de dados: registros de conjuntos de dados e resultados do método `scrape`. Os registros de conjuntos de dados podem ser exportados com o auxiliar `export()`, enquanto um resultado de `scrape` tem o auxiliar `save_to_file()`. Os [conjuntos de dados](/products/datasets) são úteis quando você precisa de dados pré-coletados em vez de scrapings novos. Para exportar registros de conjuntos de dados, crie um snapshot e baixe os registros, depois passe-os para o auxiliar `export()`, que os grava em um arquivo: ```none import asyncio from brightdata import BrightDataClient from brightdata.datasets import export async def main(): async with BrightDataClient() as client: imdb = client.datasets.imdb_movies # Cria um snapshot para os registros filtrados # (filmes com classificação IMDB de 9+ e 100+ avaliações) # depois os baixa como uma lista snapshot_id = await imdb( filter={ "operator": "and", "filters": [ {"name": "imdb_rating", "operator": ">=", "value": 9}, {"name": "imdb_rating_count", "operator": ">", "value": 100}, ], }, records_limit=10, ) data = await imdb.download(snapshot_id) export(data, "imdb_top_rated.csv") # A extensão .csv seleciona o formato CSV asyncio.run(main()) ``` **Nota**: O formato de saída é escolhido a partir da extensão, e `.json`, `.jsonl` e `.csv` são suportados. O script acima criará o seguinte arquivo `imdb_top_rated.csv` na pasta do seu projeto: ![O arquivo de saída ](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791835152372_image.png)Para exportar um resultado do método `scrape` para um arquivo, chame `save_to_file()`: ```none import asyncio from brightdata import BrightDataClient async def main(): async with BrightDataClient() as client: result = await client.scrape.linkedin.profiles( url="https://es.linkedin.com/in/antonello-zanini" ) result.save_to_file("antonello_zanini.json", format="json") # Gravado em disco asyncio.run(main()) ``` **Nota**: Apenas o formato JSON é suportado. Isso produzirá um arquivo `antonello_zanini.json` da seguinte forma: ![O arquivo de saída ](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791835250162_image.png)## SDK Python da Bright Data em Ação: Casos de Uso Depois de explorar cenários mais avançados, agora você tem a base necessária para enfrentar casos de uso reais. ### Comparar Resultados de Mecanismos de Busca Quando se trata de [monitoramento de SERP](/use-cases/serp-tracking), é importante entender como diferentes mecanismos de busca lidam com a mesma consulta. O script a seguir executa a mesma consulta no Google e no Bing: ```none # pip install brightdata-sdk import asyncio from brightdata import BrightDataClient # A consulta a ser executada em vários mecanismos de busca query = "best HTML parsers" async def main(): async with BrightDataClient() as client: # Obtém resultados de pesquisa processados do Google e do Bing google = await client.search.google(query=query, num_results=10) bing = await client.search.bing(query=query, num_results=10) # Imprime os três principais resultados de cada mecanismo de busca for name, result in [("Google", google), ("Bing", bing)]: print(f"\n{name}:") for item in result.data[:3]: print(f" - {item['title']} ({item['url']})") asyncio.run(main()) ``` Google e Bing retornam resultados orgânicos de pesquisa processados com campos como `title` e `url`. Você pode acessar esses dados diretamente, por exemplo, para imprimir os três principais resultados: ![Observe os três principais resultados recuperados no Google e no Bing para a mesma consulta de pesquisa](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791840322204_image.png)### Obter Informações Completas de Produtos da Amazon Fazer [scraping da Amazon](/blog/how-tos/how-to-scrape-amazon) é mais do que coletar dados estruturados de uma página de produto. Também pode envolver a extração de avaliações de produtos, que fornecem informações valiosas para avaliação de produtos, análise de sentimento, monitoramento e mais. Graças às diferentes Scraper APIs da Bright Data, você pode recuperar tanto informações de produtos quanto avaliações através do SDK, como mostrado abaixo: ```none # pip install brightdata-sdk import asyncio from brightdata import BrightDataClient product_url = "https://www.amazon.com/dp/B0DCH8VDXF/" async def main(): async with BrightDataClient() as client: # Recupera tanto os dados do produto quanto das avaliações product = await client.scrape.amazon.products(url=product_url) reviews = await client.scrape.amazon.reviews(url=product_url, pastDays=30, keyWord="quality") # Imprime os dados coletados print(f"Título: {product.data['title']}") print(f"Preço: {product.data['final_price']}") print(f"Avaliação: {product.data['rating']}") print(f"Avaliações obtidas: {len(reviews.data)}") asyncio.run(main()) ``` O script utilizou as opções de filtragem de `client.scrape.amazon.reviews()` para recuperar apenas avaliações dos últimos 30 dias que contenham a palavra-chave “quality”. A saída será assim: ![Observe os dados do produto e das avaliações](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791840123670_image.png)**Nota**: Os valores retornados dependem do produto e do horário da solicitação. ### Fazer Parsing de uma Página Desbloqueada com BeautifulSoup Um [roteiro comum de scraping de dados](/blog/web-data/web-scraping-roadmap) envolve: 1. Recuperar uma página web. 2. Fazer parsing dela com [um parser de HTML](/blog/web-data/best-python-html-parsers). 3. Extrair os dados necessários. O problema é que muitos sites usam [medidas anti-scraping](/blog/web-data/anti-scraping-techniques) que podem bloquear solicitações automatizadas de conteúdo HTML. Uma solução possível é acessar essas páginas através de um serviço como a Bright Data Web Unlocker API, que lida com fingerprinting de navegador, rotação de proxy, resolução de CAPTCHA e outros desafios. Por exemplo, suponha que você queira recuperar uma página de produto da [NBA Store para uma camisa do Golden State Warriors de Stephen Curry](https://store.nba.com/golden-state-warriors/mens-golden-state-warriors-stephen-curry-fanatics-royal-fast-break-replica-jersey-icon-edition/t-14140641+p-138834682113177+z-9-2551128663?_ref=p-SFLP:m-GRID:i-r0c0:po-0) e coletar seu nome, marca, preço, disponibilidade e tamanhos disponíveis. O script a seguir usa o método `scrape_url()` do SDK para buscar a página, carrega o HTML retornado [no BeautifulSoup](/blog/how-tos/beautiful-soup-web-scraping) e extrai os campos do produto: ```none # pip install brightdata-sdk beautifulsoup4 import asyncio from brightdata import BrightDataClient from bs4 import BeautifulSoup import json NBA_PRODUCT_URL = ( "https://store.nba.com/golden-state-warriors/mens-golden-state-warriors-stephen-curry-" "fanatics-royal-fast-break-replica-jersey-icon-edition/t-14140641+p-138834682113177+z-9-2551128663" "?_ref=p-SFLP:m-GRID:i-r0c0:po-0" ) async def main(): # Busca a página via scrape_url() para evitar anti-bots async with BrightDataClient() as client: result = await client.scrape_url(NBA_PRODUCT_URL) # Carrega o HTML no BeautifulSoup para fazer o parsing soup = BeautifulSoup(result.data, "html.parser") # Extrai o nome do produto do título principal da página title = soup.find("h1", attrs={"data-talos": "labelPdpProductTitle"}).get_text(strip=True) # Encontra o bloco JSON-LD que descreve o produto product_ld_data = None for script in soup.find_all("script", type="application/ld+json"): data = json.loads(script.string) if data.get("@type") == "Product": product_ld_data = data break # Acessa alguns dados dele brand = product_ld_data["brand"] images = product_ld_data["image"] # Lê o preço e disponibilidade da primeira oferta offer = product_ld_data["offers"][0] price = offer["priceSpecification"]["price"] currency = offer["priceSpecification"]["priceCurrency"] availability = offer["availability"].rsplit("/", 1)[-1] # Extrai os tamanhos, que são botões, e seu texto visível é o rótulo do tamanho (S, M, L, ...) sizes = [b.get_text(strip=True) for b in soup.find_all("button", attrs={"data-talos": "buttonSize"})] # Coleta os dados obtidos product = { "title": title, "brand": brand, "images": images, "price": price, "currency": currency, "availability": availability, "sizes": sizes, } # Imprime os dados coletados print(json.dumps(product, indent=2)) asyncio.run(main()) ``` A saída será assim: ![Os dados extraídos da página do produto da NBA desbloqueada](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791836755290_image.png)Esses campos correspondem às informações exibidas na página alvo. ![A página do produto da NBA alvo](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791840804593_image.png)## Conclusão Nesta publicação do blog, você aprendeu como o SDK Python da Bright Data fornece um único pacote Python para acessar os produtos de scraping, pesquisa e conjuntos de dados da Bright Data. Você também viu como instalar o SDK e usá-lo em cenários reais. Para saber mais, explore a [documentação oficial](https://docs.brightdata.com/api-reference/SDK), o [repositório no GitHub](https://github.com/brightdata/sdk-python) e o [diretório de exemplos](https://github.com/brightdata/sdk-python/tree/main/examples), que contém scripts funcionais para cada recurso. Se você achar o SDK útil, considere dar uma estrela ao repositório! Crie uma conta Bright Data hoje mesmo e experimente o SDK Python para simplificar o acesso às APIs da Bright Data. ## Perguntas Frequentes ### Por que o SDK Python da Bright Data é útil? Ele oferece aos desenvolvedores Python um único pacote consistente para fazer scraping de sites, executar consultas de mecanismos de busca, contornar detecção de bots e CAPTCHAs, extrair dados estruturados de plataformas e acessar mais de 100 conjuntos de dados prontos. Graças a ele, você não precisa construir essa infraestrutura sozinho. ### Preciso do CLI da Bright Data para usar o SDK? Não. O SDK funciona com um token de API definido em `BRIGHTDATA_API_KEY` ou `BRIGHTDATA_API_TOKEN`. Se você já executou `brightdata login`, o SDK recorre às credenciais armazenadas pelo CLI, então você não precisa configurar mais nada. ### Qual é a diferença entre o CLI da Bright Data, o SDK Python, o MCP e as Agent Skills? O CLI executa comandos da Bright Data a partir do seu terminal. O SDK Python permite que seu código Python chame as APIs. O servidor [MCP da Bright Data](/ai/mcp-server) fornece ferramentas de scraping e pesquisa para agentes de IA, e as [Agent Skills](/blog/ai/bright-data-skills-coding-agents) ensinam agentes de codificação a usar a Bright Data. ### Qual é a diferença entre o SDK Python da Bright Data e o SDK JavaScript da Bright Data? O SDK Python (`brightdata-sdk`, instalado com pip) oferece clientes síncronos e assíncronos com métodos em snake\_case como `scrape_url()`. O SDK JavaScript ([`@brightdata/sdk`](https://docs.brightdata.com/api-reference/SDK-JS), instalado com npm) roda no Node.js e usa métodos em camelCase como `scrapeUrl()`. ### Quando devo usar o modo síncrono ou assíncrono? Use o cliente síncrono para scripts simples e verificações rápidas, já que cada chamada bloqueia até que o resultado esteja pronto. Use o cliente assíncrono para cargas de trabalho de alta concorrência, tarefas em lote e processamento em segundo plano. Contate-nosTeste grátis![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Índice [ ](https://news.ycombinator.com/submitlink?t=Conhe%C3%A7a+o+SDK+Python+da+Bright+Data%3A+Fa%C3%A7a+Scraping%2C+Pesquise+e+Obtenha+Dados+da+Web&u=https://brightdata.com.br/blog/ai/bright-data-python-sdk) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Conhe%C3%A7a+o+SDK+Python+da+Bright+Data%3A+Fa%C3%A7a+Scraping%2C+Pesquise+e+Obtenha+Dados+da+Web&url=https://brightdata.com.br/blog/ai/bright-data-python-sdk) [ ](http://www.reddit.com/submit?title=Conhe%C3%A7a+o+SDK+Python+da+Bright+Data%3A+Fa%C3%A7a+Scraping%2C+Pesquise+e+Obtenha+Dados+da+Web&url=https://brightdata.com.br/blog/ai/bright-data-python-sdk) ## Você também pode estar interessado em [ ![Bright Data vs. Parallel](https://media.brightdata.com.br/2026/10/Bright-Data-vs.-Parallel.png) ](https://brightdata.com.br/blog/comparacao/bright-data-vs-parallel "Bright Data vs. Parallel: Qual API de Busca Web é Certa para Seu Agente de IA?") [Comparação ![Satyam Tripathi](https://media.brightdata.com.br/2024/09/Satyam-Tripathi-50x50.png) Satyam Tripathi Technical Writer ### Bright Data vs. Parallel: Qual API de Busca Web é Certa para Seu Agente de IA? A Bright Data retorna a página de resultados ao vivo do Google, enquanto a Parallel classifica trechos de seu próprio índice. Veja qual API de busca se encaixa no seu agente de IA. 18-Oct-2026 28 min de leitura ](https://brightdata.com.br/blog/comparacao/bright-data-vs-parallel) [ ![Claude Code Routines](https://media.brightdata.com.br/2026/10/Claude-Code-Routines.png) ](https://brightdata.com.br/blog/ai/claude-code-routines "Rotinas do Claude Code: Agende Monitoramento Diário da Web com Bright Data") [AI ![Satyam Tripathi](https://media.brightdata.com.br/2024/09/Satyam-Tripathi-50x50.png) Satyam Tripathi Technical Writer ### Rotinas do Claude Code: Agende Monitoramento Diário da Web com Bright Data Aprenda a dar acesso à web para rotinas do Claude Code com Bright Data e construa um monitor de preços diário que verifica cada página que lê. 18-Oct-2026 34 min de leitura ](https://brightdata.com.br/blog/ai/claude-code-routines) [ ![Is There a Google Search API](https://media.brightdata.com.br/2026/10/Is-There-a-Google-Search-API_.png) ](https://brightdata.com.br/blog/dados-do-site/google-search-api "Existe uma API de Busca do Google? Opções Após o Custom Search") [Dados do site ![Satyam Tripathi](https://media.brightdata.com.br/2024/09/Satyam-Tripathi-50x50.png) Satyam Tripathi Technical Writer ### Existe uma API de Busca do Google? Opções Após o Custom Search Aprenda a migrar da Custom Search JSON API do Google para a SERP API da Bright Data, com um adaptador cse.list() plug-and-play e mapa de parâmetros. 18-Oct-2026 8 min de leitura ](https://brightdata.com.br/blog/dados-do-site/google-search-api)