--- title: "Como extrair dados da Amazon: Guia 2026" slug: how-to-scrape-amazon date: 2023-10-29T10:11:30+00:00 modified: 2026-01-05T05:48:23+00:00 permalink: https://brightdata.com.br/blog/procedimentos/how-to-scrape-amazon type: blog --- [ Blog ](https://brightdata.com.br/blog "Blog") / [procedimentos](https://brightdata.com.br/blog/procedimentos) [procedimentos](https://brightdata.com.br/blog/procedimentos) # Como extrair dados da Amazon: Guia 2026 Aprenda a fazer scraping na Amazon usando python, bem como a usar o Navegador de scraping da Bright Data. 20 min de leitura [ ![White number one with a flame on top.](https://media.brightdata.com.br/2023/03/Favicon-2-1-50x50.png) ](https://brightdata.com/blog/authors/jakkie-koekemoer) [Jakkie Koekemoer ](https://brightdata.com/blog/authors/jakkie-koekemoer) ![How To Scrape Amazon](https://media.brightdata.com.br/2023/10/How-To-Scrape-Amazon.svg) Neste tutorial, aprenderemos como fazer scraping da Amazon usando o Bright Data e um projeto de scraping pronto para produção. Abordaremos: - Como usar a [API Amazon Scraper](/products/web-scraper/amazon) - Configurar um projeto e definir os alvos de scraping da Amazon - Busca e renderização de páginas da Amazon - Extrair dados de produtos das páginas de pesquisa e de produtos - Raspagem da Amazon usando [o Bright Data MCP da Bright Data](/ai/mcp-server) com o Claude Desktop ## Por que fazer scraping da Amazon? ![Amazon homepage](https://media.brightdata.com/2026/01/B1Q48UMEWx.png)[A Amazon](https://www.amazon.com/) é o maior mercado de produtos do mundo e uma das fontes mais ricas de dados comerciais em tempo real na internet. De tendências de preços a opinião dos clientes, a plataforma reflete o comportamento do mercado em uma escala que poucos outros sites conseguem igualar. O scraping da Amazon permite que as equipes vão além da pesquisa manual e dos Conjuntos de dados estáticos, possibilitando a tomada de decisões automatizada e baseada em dados em grande escala. ### Casos comuns de uso de scraping da Amazon Algumas das razões mais comuns pelas quais empresas e desenvolvedores coletam dados da Amazon incluem: - **Monitoramento de preços e inteligência competitiva:** acompanhe os preços dos produtos, descontos e disponibilidade de estoque em todas as categorias e vendedores quase em tempo real. - **Pesquisa de mercado e produtos:** analise listagens de produtos, categorias e classificações de best-sellers para identificar tendências de demanda e novas oportunidades. - **Análise de avaliações e sentimentos:** colete avaliações e classificações de clientes para entender o sentimento do comprador, o desempenho do produto e as lacunas de recursos. - **Aplicativos com tecnologia de IA:** alimente dados da Amazon em tempo real em LLMs e agentes de IA para tarefas como assistentes de compras, modelos de preços dinâmicos e análises de mercado automatizadas. Com os casos de uso claros, agora podemos ser práticos e percorrer as maneiras de fazer scraping da Amazon com a Bright Data. ## Extraindo dados da Amazon com a API Amazon Scraper da Bright Data Além de criar scrapers personalizados ou usar o MCP com o Claude, a Bright Data também oferece uma [API Amazon Scraper](/products/web-scraper/amazon) gerenciada. Você precisará [da](https://docs.brightdata.com/api-reference/authentication) sua [chave API](https://docs.brightdata.com/api-reference/authentication) para autenticação. ### Escolhendo um scraper da Amazon Comece abrindo a Biblioteca de Scrapers da Bright Data. Na lista de scrapers disponíveis, selecione o scraper da Amazon que corresponda ao seu caso de uso, como: - Detalhes do produto por ASIN - Resultados da pesquisa - Avaliações Cada scraper é projetado para um tipo específico de dados da Amazon. ![Amazon Scraper](https://media.brightdata.com/2026/01/S1LCvIf4Zl.png) ### Selecione o endpoint do Scraper Cada scraper oferece diferentes pontos finais, dependendo dos dados que você deseja (por exemplo, detalhes do produto, resultados de pesquisa, avaliações). Clique no endpoint adequado ao seu caso de uso. ### Crie sua solicitação ![control panel](https://media.brightdata.com/2026/01/S1wgOUzNbl.png)No painel central, você verá um formulário para configurar sua solicitação: - **Entrada única:** cole uma URL do produto, ASIN ou palavra-chave. - **CSV em massa:** carregue um arquivo CSV com várias entradas para processamento em lote. Configurações opcionais: - Esquema de saída: selecione apenas os campos necessários. - Armazenamento externo: configure S3, GCS ou Azure para entrega direta. - URL do webhook: defina um webhook para receber os resultados automaticamente. ### Faça a solicitação de API Aqui está um exemplo básico usando curl para uma página de produto: ```none curl -i --silent --compressed "https://api.brightdata.com/dca/trigger?customer=hl_ee3f47e5&zone=YOUR_ZONE_NAME" -H "Content-Type: application/json" -H "Authorization: Bearer YOUR_API_KEY" -d '{ "input": { "url": "https://www.amazon.com/dp/B08L5TNJHG" } }' ``` Substitua `YOUR_ZONE_NAME` e `YOUR_API_KEY` pela sua zona e chave API reais. \### Recupere seus resultados - Para trabalhos em tempo real (até 20 URLs), você obterá os resultados diretamente. - Para trabalhos em lote, você receberá um ID de trabalho para consultar os resultados ou obtê-los por meio de webhook/armazenamento externo. Agora, vamos ver como criar um scraper personalizado com [os proxies residenciais da Bright Data](/proxy-types/residential-proxies). ## Configuração do projeto Você pode seguir este tutorial usando o código do projeto disponível no [repositório](https://github.com/danielshashko/amazon-scraping-methods). ![project structure](https://media.brightdata.com/2026/01/BkaIUIzN-x.png)Antes de começar, certifique-se de que os seguintes pré-requisitos estejam instalados no seu sistema. ### Pré-requisitos Este projeto requer: - Python 3.10+ - pip para gerenciamento de dependências - Node.js 18+ (exigido pelo Vercel) - Vercel CLI Além disso, você precisará de: - Uma conta [Bright Data](/) - Acesso ao [Bright Data MCP da Bright Data](/ai/mcp-server) - Claude Desktop ### Instalando dependências Instale as dependências Python necessárias usando o arquivo requirements.txt fornecido: ```none pip install -r requirements.txt ``` Isso instala todas as bibliotecas usadas para busca de páginas, automação do navegador, análise de HTML e extração de dados. ### Certificado CA da Bright Data Este projeto usa um certificado Bright Data CA para verificação TLS ao encaminhar solicitações através do Proxy. Certifique-se de que o arquivo do certificado exista no seguinte caminho: ```none certs/brightdata-ca.crt ``` Este arquivo é passado para o cliente HTTP durante as solicitações. Se estiver ausente ou referenciado incorretamente, as solicitações da Amazon falharão devido a erros de verificação TLS. ### Configuração do Vercel Este projeto foi projetado para ser executado como uma função sem servidor Vercel. O arquivo `api/search.py` serve como ponto de entrada da API e é executado pelo Vercel em resposta às solicitações HTTP recebidas. Certifique-se de que o Vercel CLI esteja instalado e autenticado: ```none vercel login ``` ![vercel CLI](https://media.brightdata.com/2026/01/HksFI8MVbx.png)### Variáveis de ambiente O projeto usa configuração baseada no ambiente para definições de tempo de execução. Crie um arquivo `.env` na raiz do projeto e defina as variáveis necessárias, conforme especificado no repositório. Esses valores controlam como o scraper busca, renderiza e processa as páginas da Amazon. Com as dependências instaladas e as variáveis de ambiente configuradas, o projeto está pronto para uso. ## Entendendo a estrutura do projeto Antes de executar o scraper, precisamos entender como o projeto está organizado e como o pipeline de scraping flui do início ao fim. O projeto é estruturado em torno de uma separação clara de responsabilidades. ### Configuração Esta parte do projeto define os alvos da Amazon, as opções de tempo de execução e o comportamento do scraper. Essas configurações controlam o que é raspado e como o scraper opera. ### Busca e renderização de páginas Esta parte do projeto é responsável por carregar as páginas da Amazon e retornar HTML utilizável. Ela lida com a navegação, o carregamento da página e a execução do JavaScript para que a lógica downstream funcione com o conteúdo totalmente renderizado. ### Lógica de extração Quando o HTML está disponível, a camada de extração analisa a página e extrai dados estruturados. Isso inclui a lógica para as páginas de resultados de pesquisa da Amazon e para as páginas de produtos individuais. ### Fluxo de execução O fluxo de execução coordena a busca, a renderização, a extração e a saída. Ele garante que cada etapa seja executada na ordem correta. ### Tratamento da saída Os dados extraídos são gravados em disco em um formato estruturado, facilitando a inspeção ou o consumo em outros fluxos de trabalho. Essa estrutura mantém o scraper modular e facilita a reutilização de componentes individuais, especialmente ao integrar métodos de busca externos, como o Bright Data MCP da Bright Data, mais adiante neste tutorial. Com essa visão geral em mãos, podemos passar para a configuração dos destinos da Amazon e definir quais dados o scraper deve coletar. ## Configurando os alvos da Amazon Nesta seção, configuraremos duas coisas: 1. A palavra-chave de pesquisa da Amazon que queremos coletar 2. As credenciais da Bright Data necessárias para buscar páginas da Amazon com sucesso ### 1. Passando a palavra-chave de pesquisa da Amazon Enviamos nossa palavra-chave da Amazon usando um parâmetro de consulta chamado `q`. Isso é feito em `api/search.py`. A API lê q da URL da solicitação e para imediatamente se ela estiver faltando: ```none # api/search.py query = query_params.get("q", [None])[0] if not query: self._send_json_response(400, {"error": "Missing required parameter: q"}) return ``` O que isso significa: Devemos chamar o endpoint com `?q=...` Se esquecermos `q`, receberemos uma resposta `400` e o scraper não será executado Definindo quantos produtos queremos Também podemos controlar quantos produtos retornamos usando o parâmetro opcional limit. Ainda em `api/search.py`, analisamos `o limite`, convertemos para um número inteiro e o restringimos a um intervalo seguro: ```none # api/search.py limit_str = query_params.get("limit", [None])[0] limit = DEFAULT_SEARCH_LIMIT if limit_str: try: limit = int(limit_str) limit = min(limit, MAX_SEARCH_LIMIT) limit = max(1, limit) exceto ValueError: limite = DEFAULT_SEARCH_LIMIT ``` Portanto: Se não passarmos o limite, usamos o padrão. Se passarmos algo inválido, voltamos ao padrão. Se passarmos um valor maior do que o permitido, ele será limitado. Os valores padrão e máximo são definidos em `src/settings.py`: ```none # src/settings.py DEFAULT_SEARCH_LIMIT = 10 MAX_SEARCH_LIMIT = 50 ``` Se quisermos alterar o comportamento padrão, é aqui que o fazemos. ### 2. Mapeando nossa consulta para o endpoint de pesquisa da Amazon Depois de obtermos `q`, buscamos os resultados da pesquisa da Amazon através da Bright Data usando `fetch_products(query, limit)`: ```none # api/search.py raw_response = fetch_products(query, limit) ``` O endpoint da Amazon que está sendo rastreado é definido em `src/brightdata_client.py`: ```none # src/brightdata_client.py AMAZON_SEARCH_URL = "https://www.amazon.com/s" ``` E quando buscamos os resultados, passamos nossa palavra-chave para a Amazon usando o parâmetro `k`: ```none # src/brightdata_client.py r = requests.get( AMAZON_SEARCH_URL, params={"k": query}, proxies=proxies, headers=headers, timeout=60, verify=BRIGHTDATA_CA_CERT_PATH, ) ``` Isso significa: - Nosso parâmetro API é `q` - O parâmetro de pesquisa da Amazon é `k` - Se fornecermos q=fones de ouvido sem fio, a solicitação será enviada à Amazon como `https://www.amazon.com/s?k=wireless+headphones` ![Headphones page](https://media.brightdata.com/2026/01/rkyT8IGEZe.png)### 3. Configurando as credenciais da Bright Data Para enviar solicitações através da Bright Data, precisamos das credenciais do Proxy disponíveis como variáveis de ambiente. Em `src/settings.py`, carregamos as configurações da Bright Data assim: ```none # src/settings.py BRIGHTDATA_USERNAME = os.getenv('BRIGHTDATA_USERNAME', '') BRIGHTDATA_PASSWORD = os.getenv('BRIGHTDATA_PASSWORD', '') BRIGHTDATA_PROXY_HOST = os.getenv('BRIGHTDATA_PROXY_HOST', 'brd.superproxy.io') BRIGHTDATA_PROXY_PORT = os.getenv('BRIGHTDATA_PROXY_PORT', 'your_port) ``` No seu arquivo `.env`, adicione as seguintes credenciais: ```none BRIGHTDATA_USERNAME=seu_nome_de_usuário_brightdata BRIGHTDATA_PASSWORD=sua_senha_brightdata BRIGHTDATA_PROXY_HOST=brd.superproxy.io BRIGHTDATA_PROXY_PORT=sua_porta ``` Quando executamos o scraper, esses valores são usados para construir a URL do Proxy Bright Data dentro de `src/brightdata_client.py`: ```none # src/brightdata_client.py proxy_url = ( f"http://{BRIGHTDATA_USERNAME}:{BRIGHTDATA_PASSWORD}" f"@{BRIGHTDATA_PROXY_HOST}:{BRIGHTDATA_PROXY_PORT}") proxies = {"http": proxy_url, "https": proxy_url} ``` Se não definirmos `BRIGHTDATA_USERNAME` ou `BRIGHTDATA_PASSWORD`, o scraper falhará logo no início com um erro claro: ```none # src/brightdata_client.py if not BRIGHTDATA_USERNAME or not BRIGHTDATA_PASSWORD: raise ValueError( "Credenciais de Proxy Bright Data não configuradas. " "Defina BRIGHTDATA_USERNAME e BRIGHTDATA_PASSWORD." ) ``` Com nossa palavra-chave e as credenciais do Bright Data configuradas, estamos prontos para buscar páginas da Amazon. ## Buscando páginas da Amazon Nesta fase, já validamos a entrada e configuramos o Bright Data. Agora vamos nos concentrar em onde a solicitação da Amazon é executada e quais são as premissas mínimas que ela faz. Todas as solicitações da Amazon são enviadas de `src/brightdata_client.py`. ### Ponto final de pesquisa da Amazon Definimos o endpoint de pesquisa da Amazon uma vez e o reutilizamos para todas as solicitações de pesquisa: ```none # src/brightdata_client.py AMAZON_SEARCH_URL = "https://www.amazon.com/s" ``` ### Cabeçalhos de solicitação Enviamos cabeçalhos genéricos, semelhantes aos do navegador, para garantir que a Amazon retorne o layout HTML padrão para desktop. Esses cabeçalhos não estão vinculados ao sistema operacional do usuário. ```none # src/brightdata_client.py headers = { "User-Agent": ( "Mozilla/5.0 " "AppleWebKit/537.36 (KHTML, like Gecko) " "Chrome/120.0 Safari/537.36" ), "Accept-Language": "en-US,en;q=0.9", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", } ``` ### Enviando a solicitação Com o endpoint, os cabeçalhos e a configuração do Proxy já definidos, executamos a solicitação da Amazon: ```none # src/brightdata_client.py response = requests.get( AMAZON_SEARCH_URL, params={"k": query}, proxies=proxies, headers=headers, timeout=60, verify=BRIGHTDATA_CA_CERT_PATH,) response.raise_for_status() html = response.text or "" ``` No final dessa chamada, html contém o conteúdo bruto da página de pesquisa da Amazon. Com a fase de busca concluída, agora podemos passar para o parsing do HTML e extrair links de produtos e metadados da página de resultados de pesquisa da Amazon. ## Extraindo resultados de pesquisa Depois que a página de pesquisa da Amazon é buscada, a próxima etapa é extrair as listagens de produtos do HTML retornado. Toda essa etapa ocorre dentro `do src/brightdata_client.py`. Após a conclusão da solicitação, passamos o HTML bruto para o analisador interno: ```none products = _parse_amazon_search_html(html, limit=limit) return {"products": products} ``` Toda a lógica de extração dos resultados da pesquisa está dentro de `_parse_amazon_search_html`. ### Parsing o HTML Começamos analisando o HTML bruto em uma árvore DOM usando o BeautifulSoup. Isso nos permite consultar a estrutura da página de maneira confiável. ```none soup = BeautifulSoup(html, "lxml") ``` Também normalizamos o limite solicitado para garantir que sempre extraímos pelo menos um item: ```none max_items = max(1, int(limite)) if isinstance(limite, int) else 10 ``` ### Localizando contêineres de resultados de pesquisa As páginas de pesquisa da Amazon incluem muitos elementos que não são listagens de produtos. Para isolar os resultados reais, primeiro direcionamos o contêiner de resultados de pesquisa principal da Amazon: ```none containers = soup.select('div[data-component-type="s-search-result"]') ``` Como alternativa, também procuramos elementos que contenham um atributo data-asin válido: ```none fallback = soup.select('div[data-asin]:not([data-asin=""])') ``` Se o seletor principal não retornar resultados, mas o alternativo sim, mudamos para o alternativo: ```none if not containers and fallback: containers = fallback ``` Isso nos dá resiliência contra pequenas variações de layout, mantendo a extração restrita às entradas reais do produto. Iterando pelos resultados Iteramos pelos contêineres selecionados e paramos quando atingimos o limite solicitado: ```none produtos = [] para c em contêineres: se len(produtos) >= max_items: break ``` Para cada contêiner, extraímos os campos principais. Se um cartão de produto não contiver um título e uma URL, nós o ignoramos. ```none title = _extract_title(c) url = _extract_url(c) if not title or not url: continue ``` ### Extraindo campos do produto Cada cartão de produto é analisado usando pequenas funções auxiliares, todas definidas no mesmo arquivo. ```none imagem = _extract_image(c) classificação = _extract_rating(c) avaliações = _extract_reviews_count(c) preço = _extract_price(c) ``` Em seguida, montamos um objeto de produto estruturado: ```none products.append( { "title": title, "price": price, "rating": rating, "reviews": reviews, "url": url, "image": image, } ) ``` ### Auxiliares de extração de campos Cada auxiliar se concentra em um campo e lida com marcações ausentes ou parciais com segurança. #### Extração de título ```none def _extract_title(container) -> str: a = container.select_one('a.a-link-normal[href*="/dp/"]') if a: t = a.get_text(" ", strip=True) if t: return t img = container.select_one("img.s-image") alt = img.get("alt") if img else "" return alt.strip() if isinstance(alt, str) else "" ``` #### URL do produto ```none def _extract_url(container) -> str: a = container.select_one('a.a-link-normal[href*="/dp/"]') href = a.get("href") se a, caso contrário "" if isinstance(href, str) and href: return "https://www.amazon.com" + href if href.startswith("/") else href return "" ``` #### Imagem ```none def _extract_image(container) -> Optional[str]: img = container.select_one("img.s-image") src = img.get("src") if img else None return src if isinstance(src, str) and src else None ``` #### Classificação ```none def _extract_rating(container) -> Optional[float]: el = container.select_one("span.a-icon-alt") text = el.get_text(" ", strip=True) if el else "" if not text: el = container.select_one('span:contains("out of 5 stars")') text = el.get_text(" ", strip=True) se el, caso contrário, "" se não houver texto: retorne None m = re.search(r"(d+(?:.d+)?)", text) retorne float(m.group(1)) se m, caso contrário, None ``` #### Contagem de avaliações ```none def _extract_reviews_count(container) -> Optional[int]: el = container.select_one("span.s-underline-text") text = el.get_text(" ", strip=True) if el else "" m = re.search(r"(d[d,]*)", text) return int(m.group(1).replace(",", "")) if m else None ``` #### Preço ```none def _extract_price(container) -> str: whole = container.select_one("span.a-price-whole") frac = container.select_one("span.a-price-fraction") whole_text = whole.get_text(strip=True).replace(",", "") if whole else "" frac_text = frac.get_text(strip=True) se frac, caso contrário, "" se não whole_text: retornar "" retornar f"${whole_text}.{frac_text}" se frac_text, caso contrário, f"${whole_text}" ``` No final desta etapa, temos uma lista de entradas de produtos estruturadas extraídas diretamente dos resultados de pesquisa da Amazon. Cada item inclui: - título - preço - classificação - avaliações - URL do produto - URL da imagem Com a extração dos resultados da pesquisa concluída, passamos para a normalização e o retorno da resposta, que é tratada em `src/normalize.py`. ## Normalizando a resposta Neste ponto, nossa extração de pesquisa retorna objetos de produto, mas os campos ainda não estão padronizados. Por exemplo, o preço ainda é uma string (como “$129,99”), a contagem de avaliações pode incluir vírgulas e alguns campos podem estar faltando, dependendo do cartão. Para tornar a resposta da API consistente, normalizamos tudo dentro de `src/normalize.py`. Em api/search.py, a normalização ocorre logo após buscarmos os resultados brutos: ```none # api/search.py normalized = normalize_response(raw_response, query) ``` Essa única chamada converte a saída bruta da Bright Data em uma resposta limpa que sempre se parece com: - `itens`: uma lista de objetos de produto normalizados - `count`: quantos itens retornamos ### Normalizando uma resposta dict `normalize_response` suporta vários tipos de entrada. Em nosso fluxo de API, passamos um dict como `{"products": [...]}` de `fetch_products(...)`. Aqui está o ramo dict: ```none # src/normalize.py if isinstance(raw_response, dict): products = raw_response.get("products", []) or raw_response.get("items", []) normalized_items = [normalize_product(p) for p in products if isinstance(p, dict)] return {"items": normalized_items[:limit], "count": len(normalized_items[:limit])} ``` O que isso faz: - Lê os produtos de products (ou itens, se houver) - Normaliza cada produto usando normalize\_product - Retorna uma carga útil consistente `{"items": [...], "count": N}` ### Normalizando um único produto Cada produto é normalizado por `normalize_product(...)`. O preço é analisado em um valor numérico e um código de moeda usando `parse_price(...):` ```none # src/normalize.py price_str = raw_product.get("price", "") price, currency = parse_price(price_str) ``` A classificação é convertida em um float, se possível: ```none # src/normalize.py rating = raw_product.get("rating") if rating is not None: try: rating = float(rating) except (ValueError, TypeError): rating = None else: rating = None ``` As contagens de avaliações são normalizadas em um número inteiro, suportando as chaves `reviews` e `reviews_count`: ```none # src/normalize.py reviews_count = raw_product.get("reviews") ou raw_product.get("reviews_count") se reviews_count não for None: tente: reviews_count = int(str(reviews_count).replace(",", "")) exceto (ValueError, TypeError): contagem_de_avaliações = Nenhum caso contrário: contagem_de_avaliações = Nenhum ``` Por fim, retornamos um objeto de produto padronizado: ```none # src/normalize.py return { "title": raw_product.get("title", ""), "price": price, "currency": currency, "rating": rating, "reviews_count": reviews_count, "url": raw_product.get("url", ""), "image": raw_product.get("image"), "source": "brightdata", } ``` Com a normalização concluída, agora temos uma lista de itens consistente que é segura para retornar da API e fácil para os clientes consumirem. ## Executando o Scraper no Vercel Este scraper é executado como uma [função sem servidor do Vercel](https://vercel.com/docs/functions). Localmente, nós o executamos usando o servidor de desenvolvimento do Vercel para que as rotas api/ se comportem da mesma forma que na produção. ### Executar localmente com o Vercel Na raiz do repositório, inicie o servidor de desenvolvimento: ```none vercel dev ``` ![terminal output](https://media.brightdata.com/2026/01/rynmPUzEWe.png)Por padrão, isso inicia o servidor em: ```none http://localhost ``` ![Vercel page](https://media.brightdata.com/2026/01/ryKgPUMVWl.png)Agora temos nosso projeto completo de scraper em funcionamento. Você pode executá-lo e tentar fazer o scraping de diferentes produtos da Amazon. Além disso, você também pode fazer scraping usando o Bright Data MCP com um agente de IA. Vamos ver como você pode fazer isso rapidamente. ## Conectando o Claude Desktop ao Bright Data MCP da Bright Data [O Claude Desktop](https://claude.com/download) deve ser configurado para iniciar o servidor Bright Data MCP da Bright Data. Abra o arquivo de configuração do Claude Desktop. Você pode navegar até Configurações, clicar no ícone Desenvolvedor e selecionar Editar Configuração. Isso abre o arquivo de configuração usado pelo Claude Desktop. ![Claude settings](https://media.brightdata.com/2026/01/SkYOvLfE-g.png)Adicione a seguinte configuração e substitua `YOUR_TOKEN_HERE` pelo seu token da API da Bright Data: ```none { "mcpServers": { "brightdata": { "command": "npx", "args": ["-y", "@brightdata/mcp"], "env": { "API_TOKEN": "YOUR_TOKEN_HERE" } } } } ``` Salve o arquivo e reinicie o Claude Desktop. Assim que o Claude reiniciar, o Bright Data MCP da Bright Data estará disponível como uma ferramenta. ### Extraindo listagens de produtos da Amazon com o Claude Com o Bright Data MCP da Bright Data conectado, podemos pedir ao Claude para buscar e extrair resultados de pesquisa da Amazon em uma única etapa. Use um prompt como este: ```none Use a ferramenta scrape_as_markdown para acessar: https://www.amazon.com/s?k=wireless+headphones Em seguida, observe a saída do markdown e extraia todas as listagens de produtos para uma lista JSON com os seguintes campos: - título - preço - classificação - número de avaliações - URL do produto - URL da imagem ``` O Claude irá buscar a página através do Bright Data MCP da Bright Data, analisar o conteúdo renderizado e retornar uma resposta JSON estruturada contendo os dados do produto extraídos da Amazon. ![Claude Output](https://media.brightdata.com/2026/01/Sy4svLM4be.png)## Considerações finais Neste tutorial, exploramos três maneiras de fazer scraping da Amazon usando a Bright Data: 1. **Amazon Scraper API**– A maneira mais rápida de começar. Use endpoints pré-construídos para detalhes do produto, resultados de pesquisa e avaliações sem escrever nenhum código de scraping. 2. **Scraper personalizado com proxies da Bright Data**– Crie um scraper pronto para produção como uma função sem servidor Vercel com controle total sobre a obtenção, extração e normalização. 3. **Claude Desktop com Bright Data MCP**– Extraia dados da Amazon de forma interativa usando extração com IA sem escrever código. ### Ignore completamente a extração Se você precisa de dados da Amazon em grande escala e prontos para produção sem construir infraestrutura, considere [os Conjuntos de Dados da Amazon da Bright Data](https://brightdata.com/products/datasets/amazon). Tenha acesso a: - Listas de produtos, preços e avaliações pré-coletados - Dados históricos para análise de tendências - Conjuntos de dados prontos para uso e atualizados regularmente - Cobertura em vários mercados da Amazon Se você precisa de scraping em tempo real ou conjuntos de dados prontos, a Bright Data fornece a infraestrutura para acessar os dados da Amazon de forma confiável e em grande escala. Contate-nosTeste grátis![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Índice Dedicated Scraper APIs & No-Code Scrapers Over 1000 scrapers for all popular domains. Simplify your web scraping. [See pricing](/pricing/web-scraper "See pricing") Just want data? Skip scraping. Hundreds of ready-to-use datasets from all popular domains. [See pricing](/pricing/datasets "See pricing") [ ](https://news.ycombinator.com/submitlink?t=Como+extrair+dados+da+Amazon%3A+Guia+2026&u=https://brightdata.com.br/blog/procedimentos/how-to-scrape-amazon) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Como+extrair+dados+da+Amazon%3A+Guia+2026&url=https://brightdata.com.br/blog/procedimentos/how-to-scrape-amazon) [ ](http://www.reddit.com/submit?title=Como+extrair+dados+da+Amazon%3A+Guia+2026&url=https://brightdata.com.br/blog/procedimentos/how-to-scrape-amazon) ## Você também pode estar interessado em [ ![Best scraping proxies](https://media.brightdata.com.br/2023/07/Best-web-scraping-proxies.svg) ](https://brightdata.com.br/blog/proxies-101/best-scraping-proxies-guide "Melhores proxies para web scraping: um guia completo") [Proxy 101 ![Antonello Zanini](https://media.brightdata.com.br/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Melhores proxies para web scraping: um guia completo Quais são os melhores proxies para scraping? Saiba mais sobre os diferentes tipos de proxy e veja qual tipo de proxy é mais adequado às suas necessidades de web scraping. 25-Jul-2023 9 min de leitura ](https://brightdata.com.br/blog/proxies-101/best-scraping-proxies-guide) [ ![How to scrape ecommerce websites](https://media.brightdata.com.br/2023/07/blog-image-for-how-to-scrape-ecommerce-sites-1.svg) ](https://brightdata.com.br/blog/procedimentos/ecommerce-web-scraping-guide "Guia para a raspagem de sítios web de comércio eletrónico") [procedimentos ### Guia para a raspagem de sítios web de comércio eletrónico Neste guia passo-a-passo, aprenda a raspar sítios de comércio eletrónico utilizando Playwright e o Navegador de Raspagem da Bright Data. 17-Jul-2023 11 min de leitura ](https://brightdata.com.br/blog/procedimentos/ecommerce-web-scraping-guide) [ ![Best web scraping services](https://media.brightdata.com.br/2023/06/Best-web-scraping-services.svg) ](https://brightdata.com.br/blog/dados-do-site/best-web-scraping-services-guide "Como escolher o melhor serviço de raspagem da web: Um guia completo") [Dados do site ![Antonello Zanini](https://media.brightdata.com.br/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Como escolher o melhor serviço de raspagem da web: Um guia completo Guia dos melhores serviços de raspagem da web Leia sobre o que deve ter em conta ao avaliar um fornecedor de raspagem da web e as 5 coisas a não fazer ao selecionar serviços de raspagem 28-Jun-2023 13 min de leitura ](https://brightdata.com.br/blog/dados-do-site/best-web-scraping-services-guide)