Extrair dados de produtos da Amazon com Python: Guia Prático

Antes de escrever uma única linha de código, é útil saber o que pretende resolver. Os dados de produtos da Amazon alimentam uma variedade surpreendente de fluxos de trabalho no mundo real:

• Monitorização e análise de preços. Retalhistas e revendedores acompanham os preços da concorrência em milhares de ASINs para ajustar os seus próprios preços de forma dinâmica.
• Pesquisa de mercado e análise de tendências. Os analistas estudam as classificações dos mais vendidos, o número de avaliações e as distribuições por categoria para identificar tendências emergentes de produtos.
• Análise de avaliações e sentimentos. As equipas de produto extraem as avaliações de produtos da Amazon para compreender os pontos fracos dos clientes, os pedidos de funcionalidades e os sinais de qualidade em grande escala.
• Dados de treino de ML e IA. Os catálogos de produtos estruturados servem como conjuntos de dados rotulados para motores de recomendação, classificadores de imagens e modelos de linguagem natural.

Como a Amazon agrega dados de milhões de vendedores em praticamente todas as categorias de consumo, o seu catálogo é excepcionalmente abrangente. A recolha destes dados permite às empresas monitorizar o posicionamento dos produtos, os padrões de preços e as mudanças na procura do mercado que seriam invisíveis apenas através da navegação manual.

Esta é a pergunta que todos fazem em primeiro lugar, e a resposta honesta é: depende do que se extrai e de como o faz.

As Condições de Utilização da Amazon proíbem explicitamente «a utilização de qualquer robô, spider, scraper ou outros meios automatizados para aceder ao Serviço para qualquer finalidade». Essa linguagem é abrangente, e a Amazon já a aplicou no passado. Ao mesmo tempo, a decisão de 2022 no caso hiQ Labs v. LinkedIn nos Estados Unidos determinou que a extração de dados publicamente disponíveis não viola a Lei de Fraude e Abuso Informático, pelo menos nesse contexto específico. Os tribunais de outras jurisdições podem chegar a conclusões diferentes.

Na prática, a maioria dos programadores que extraem páginas de produtos da Amazon segue algumas diretrizes responsáveis: recolher apenas informações visíveis publicamente, nunca aceder a dados pessoais protegidos por login, respeitar os limites de taxa e evitar sobrecarregar os servidores com volumes agressivos de pedidos. Consulte um advogado qualificado se o seu caso de utilização envolver a recolha de dados comerciais em grande escala. O rastreador de reformas da CFAA da EFF é um recurso útil para se manter atualizado sobre o panorama jurídico em evolução em torno do acesso automatizado a dados.

Nem todos os projetos precisam de um scraper personalizado. Antes de mergulhar no código, considere qual a abordagem que corresponde ao seu nível técnico, orçamento e tolerância à manutenção. Aqui está um quadro de decisão rápido:

Se pretende compreender exatamente como as páginas da Amazon estão estruturadas e precisa de controlo total sobre cada seletor CSS, a via DIY em Python é ideal para aprender a extrair listagens de produtos da Amazon por conta própria. Se a sua prioridade é a entrega fiável de dados sem ter de gerir um conjunto de proxies, uma API de extração dedicada elimina grande parte das dificuldades operacionais. E se é um analista de negócios que prefere não mexer num terminal, várias plataformas sem código permitem-lhe configurar extratores da Amazon através de uma interface visual.

O resto deste guia centra-se na abordagem DIY em Python, mas voltaremos à abordagem da API mais tarde com um exemplo de código concreto.

Precisa do Python 3.8 ou posterior e de três pacotes. Abra um terminal e execute:

pip install requests beautifulsoup4 lxml

• O Requests gere a camada HTTP: enviando pedidos GET, gerindo cabeçalhos e recebendo respostas.
• O BeautifulSoup analisa a cadeia de HTML bruta, transformando-a numa árvore navegável que pode consultar com seletores CSS.
• O lxml é um backend de análise opcional, mas recomendado. É significativamente mais rápido do que o integrado no Python html.parser para documentos grandes.

Crie um novo ficheiro Python (por exemplo, amazon_scraper.py) e verifique as instalações:

import requests
from bs4 import BeautifulSoup

print("Environment ready")

Se isso for executado sem erros, está tudo pronto.

Antes de escrever a lógica de análise, precisa de saber o que está a analisar. As listagens de produtos da Amazon aparecem em dois tipos principais de páginas: páginas de resultados de pesquisa e páginas individuais de detalhes do produto. Ambas contêm dados estruturados, mas o layout HTML difere.

Numa página de resultados de pesquisa, cada cartão de produto está dentro de um div com o atributo data-component-type="s-search-result". Dentro desse contêiner, normalmente encontrará:

• Título: uma h2 que envolve uma âncora (a) com o nome do produto.
• Preço: uma span com a classe a-price que contém um span.a-offscreen que contém a string do preço formatada.
• Classificação: um span.a-icon-alt dentro do bloco de classificação por estrelas, com texto como «4,5 de 5 estrelas».
• ASIN: armazenado como um data-asin atributo diretamente no resultado da pesquisa div.
• Imagem: uma img tag com a classe s-image cujo src aponta para a miniatura do produto.

Use as Ferramentas de Desenvolvedor do seu navegador (clique com o botão direito, Inspecionar) para confirmar estes seletores numa página ativa. A Amazon altera ocasionalmente os nomes das classes e a estrutura do layout, por isso valide sempre os seletores antes de uma execução em produção. Muitos produtos da Amazon também apresentam várias variações (cor, tamanho, modelo), e cada variação pode ter o seu próprio preço, imagem e disponibilidade. Os dados de variação normalmente encontram-se na página de detalhes do produto, em vez de na página de resultados de pesquisa, frequentemente incorporados num objeto JavaScript que terá de analisar separadamente.

Vamos juntar as peças. O fluxo de trabalho do scraper tem três fases: solicitar a página, verificar a resposta e analisar o HTML. Aqui está a base:

import requests
from bs4 import BeautifulSoup

HEADERS = {
    "User-Agent": (
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
        "AppleWebKit/537.36 (KHTML, like Gecko) "
        "Chrome/120.0.0.0 Safari/537.36"
    ),
    "Accept-Language": "en-US,en;q=0.9",
}

url = "https://www.amazon.com/s?k=mechanical+keyboard"
response = requests.get(url, headers=HEADERS)

if response.status_code == 200:
    soup = BeautifulSoup(response.text, "lxml")
    print(f"Page fetched: {len(response.text)} bytes")
else:
    print(f"Request failed with status {response.status_code}")

O User-Agent cabeçalho é fundamental quando se extraem páginas de produtos da Amazon. Sem ele, a Amazon irá quase certamente devolver uma página CAPTCHA ou um estado 503. Está essencialmente a anunciar-se como um navegador normal, em vez de um simples script Python.

Depois de ter o objeto soup , percorra cada ficha de produto e extraia os atributos principais:

products = []
cards = soup.select('div[data-component-type="s-search-result"]')

for card in cards:
    title_tag = card.select_one("h2 a span")
    price_tag = card.select_one("span.a-price span.a-offscreen")
    rating_tag = card.select_one("span.a-icon-alt")

    product = {
        "title": title_tag.get_text(strip=True) if title_tag else None,
        "price": price_tag.get_text(strip=True) if price_tag else None,
        "rating": rating_tag.get_text(strip=True) if rating_tag else None,
    }
    products.append(product)

print(f"Found {len(products)} products")

Cada select_one chamada tem como alvo um seletor CSS específico. As verificações condicionais impedem que o seu script falhe quando falta um elemento num cartão (os resultados patrocinados, por exemplo, por vezes omitem o preço).

As imagens e os ASINs são mais fáceis de obter porque residem diretamente no contêiner do cartão:

for i, card in enumerate(cards):
    asin = card.get("data-asin", "")
    img_tag = card.select_one("img.s-image")
    img_url = img_tag["src"] if img_tag else None

    products[i]["asin"] = asin
    products[i]["image_url"] = img_url

O ASIN (Amazon Standard Identification Number) é um identificador único do produto. É útil para a deduplicação, a criação de URLs de páginas de detalhes do produto (https://www.amazon.com/dp/{ASIN}) e para unir conjuntos de dados entre execuções de scraping.

Uma única página de pesquisa da Amazon mostra cerca de 20 a 60 resultados. Se precisar de milhares de produtos, terá de extrair as listagens de produtos da Amazon em várias páginas. A Amazon utiliza um page parâmetro de consulta que pode ser incrementado:

import time

all_products = []
base_url = "https://www.amazon.com/s?k=mechanical+keyboard&page={page}"

for page_num in range(1, 11):  # pages 1 through 10
    url = base_url.format(page=page_num)
    response = requests.get(url, headers=HEADERS)

    if response.status_code != 200:
        print(f"Stopped at page {page_num}: status {response.status_code}")
        break

    soup = BeautifulSoup(response.text, "lxml")
    cards = soup.select('div[data-component-type="s-search-result"]')

    if not cards:
        print(f"No results on page {page_num}, stopping.")
        break

    for card in cards:
        title_tag = card.select_one("h2 a span")
        price_tag = card.select_one("span.a-price span.a-offscreen")
        all_products.append({
            "title": title_tag.get_text(strip=True) if title_tag else None,
            "price": price_tag.get_text(strip=True) if price_tag else None,
        })

    time.sleep(2)  # respect rate limits

print(f"Total products collected: {len(all_products)}")

Há duas coisas a ter em conta. Primeiro, a time.sleep(2) chamada adiciona uma pausa de dois segundos entre os pedidos. Sem esse intervalo, a Amazon irá sinalizar o seu IP quase imediatamente. Segundo, o loop verifica se a cards como condição de terminação, porque a Amazon devolve uma resposta 200 válida mesmo quando já não há mais resultados.

Para tarefas em grande escala que abrangem centenas de páginas, considere distribuir as solicitações por um conjunto rotativo de proxies. A extração local a partir de um único IP atingirá rapidamente os limites de taxa.

A Amazon é conhecida por bloquear scrapers, e por um bom motivo: a plataforma lida com milhares de milhões de visualizações de páginas. As suas defesas são em camadas, e compreender cada camada ajuda-o a decidir como responder.

AWS WAF (Web Application Firewall). A Amazon utiliza o seu próprio produto de firewall na nuvem para inspecionar os pedidos recebidos. O WAF analisa o seu endereço IP, cabeçalhos HTTP, impressão digital TLS e padrões de comportamento (frequência de pedidos, sequência de navegação). Se algum sinal parecer não humano, o pedido é bloqueado imediatamente ou redirecionado para um desafio CAPTCHA.

Desafios CAPTCHA. Quando o WAF sinaliza uma solicitação, normalmente aparece uma página a pedir que resolva um CAPTCHA de imagem ou texto. Um scraper básico baseado em Requests não tem como resolver estes automaticamente. As opções incluem integrar um serviço de resolução de CAPTCHA, mudar para um navegador headless ou encaminhar as solicitações através de uma API de scraping que lida com CAPTCHAs nos bastidores.

Bloqueio de IP e limitação de taxa. O envio de demasiadas solicitações a partir do mesmo IP num curto espaço de tempo desencadeia bloqueios temporários ou permanentes. A rotação de proxies residenciais faz com que o seu tráfego pareça ter origem em diferentes ligações domésticas, o que é muito mais difícil para o WAF distinguir de visitas orgânicas.

Análise de cabeçalhos e impressões digitais. Cabeçalhos de solicitação básicos (sem Accept-Language, Accept-Encodingou um User-Agent) são um sinal de alerta imediato. Randomize a sua string User-Agent nas solicitações e inclua o mesmo conjunto de cabeçalhos que um navegador real enviaria.

Se pretende mesmo criar um scraper de produtos da Amazon fiável em Python, planeie investir, no mínimo, na rotação de proxies e na aleatorização de cabeçalhos. Para a maioria dos casos de utilização em produção, uma API de scraping dedicada que agrupe estas proteções num único ponto de extremidade é a escolha pragmática.

Aqui está um script consolidado que combina a configuração do ambiente, o tratamento de pedidos, a análise e a paginação num único ficheiro executável. Adapte o termo de pesquisa e o intervalo de páginas às suas necessidades.

import requests
from bs4 import BeautifulSoup
import time
import json
import csv

HEADERS = {
    "User-Agent": (
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
        "AppleWebKit/537.36 (KHTML, like Gecko) "
        "Chrome/120.0.0.0 Safari/537.36"
    ),
    "Accept-Language": "en-US,en;q=0.9",
    "Accept-Encoding": "gzip, deflate, br",
    "Accept": "text/html,application/xhtml+xml",
}

def scrape_amazon(query, max_pages=5):
    all_products = []
    for page in range(1, max_pages + 1):
        url = f"https://www.amazon.com/s?k={query}&page={page}"
        resp = requests.get(url, headers=HEADERS)
        if resp.status_code != 200:
            print(f"Page {page}: HTTP {resp.status_code}")
            break
        soup = BeautifulSoup(resp.text, "lxml")
        cards = soup.select('div[data-component-type="s-search-result"]')
        if not cards:
            break
        for card in cards:
            all_products.append({
                "asin": card.get("data-asin", ""),
                "title": _text(card, "h2 a span"),
                "price": _text(card, "span.a-price span.a-offscreen"),
                "rating": _text(card, "span.a-icon-alt"),
                "image": card.select_one("img.s-image")["src"]
                         if card.select_one("img.s-image") else None,
            })
        time.sleep(2)
    return all_products

def _text(card, selector):
    tag = card.select_one(selector)
    return tag.get_text(strip=True) if tag else None

if __name__ == "__main__":
    results = scrape_amazon("wireless+earbuds", max_pages=3)
    print(f"Scraped {len(results)} products")

Algumas anotações que vale a pena destacar. O _text função auxiliar mantém o ciclo de análise compacto e evita verificações repetidas None . O Accept-Encoding e Accept completam a impressão digital da solicitação para que pareça mais próxima de um navegador real. E envolver tudo numa função facilita a integração num pipeline maior ou a chamada a partir de um agendador.

Os dicionários Python em bruto são úteis para depuração, mas as ferramentas a jusante (folhas de cálculo, carregadores de bases de dados, cadernos de análise) esperam um formato de ficheiro padrão. Veja aqui como exportar os seus dados de produtos da Amazon extraídos tanto em CSV como em JSON.

A exportação para CSV funciona bem para análise tabular no Excel, Google Sheets ou pandas:

import csv

def export_csv(products, filename="amazon_products.csv"):
    if not products:
        return
    keys = products[0].keys()
    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=keys)
        writer.writeheader()
        writer.writerows(products)
    print(f"Exported {len(products)} rows to {filename}")

A exportação para JSON é a melhor escolha quando precisa de dados aninhados, planeia carregar os resultados numa base de dados NoSQL ou pretende alimentar os dados numa API:

import json

def export_json(products, filename="amazon_products.json"):
    with open(filename, "w", encoding="utf-8") as f:
        json.dump(products, f, indent=2, ensure_ascii=False)
    print(f"Exported {len(products)} items to {filename}")

Quando usar cada um: escolha CSV se os seus utilizadores forem analistas que trabalham com folhas de cálculo ou se precisar de uma importação rápida para uma tabela SQL. Escolha JSON se estiver a construir pipelines de dados, precisar de preservar estruturas aninhadas (como variações de produtos) ou quiser um formato que se mapeie diretamente para cargas de API.

A abordagem «faça você mesmo» dá-lhe controlo total, mas também significa que é responsável por todos os modos de falha: proxies avariados, barreiras CAPTCHA, seletores rotativos e bloqueios de IP. Se o seu objetivo é extrair páginas de produtos da Amazon de forma fiável num pipeline de produção, transferir a camada de pedidos para uma API de scraping dedicada pode poupar muito tempo de engenharia.

Uma API de scraping situa-se entre o seu código e o site de destino. Envia uma solicitação HTTP normal para o endpoint da API com a URL da Amazon como parâmetro, e o serviço lida internamente com a rotação de proxies, gestão de cabeçalhos, resolução de CAPTCHA e novas tentativas. Recebe em troca HTML limpo (ou, em alguns casos, JSON pré-analisado) que pode alimentar diretamente no seu código de análise BeautifulSoup.

Aqui está um exemplo mínimo de como isso funciona na prática:

import requests
from bs4 import BeautifulSoup

API_URL = "https://api.example.com/v1/scrape"
API_KEY = "your_api_key_here"

params = {
    "url": "https://www.amazon.com/s?k=usb+c+hub",
    "api_key": API_KEY,
    "render_js": "false",
}

response = requests.get(API_URL, params=params)
soup = BeautifulSoup(response.text, "lxml")
# Parse exactly as before
cards = soup.select('div[data-component-type="s-search-result"]')
print(f"Found {len(cards)} results via API")

Repare que o seu código de análise não muda de todo. A única diferença é a URL da solicitação e a adição de uma chave de API. Essa é a principal vantagem: você separa a recuperação da análise e pode alternar entre a recuperação DIY e a recuperação via API sem reescrever a sua lógica de extração.

Para equipas que precisam diretamente de JSON estruturado (saltando completamente a etapa de análise de HTML), alguns serviços oferecem scrapers da Amazon pré-construídos que devolvem títulos de produtos, preços e classificações como campos JSON prontos a usar.

É aqui que as coisas ficam interessantes. Depois de estruturar os dados de produtos da Amazon, pode canalizá-los diretamente para fluxos de trabalho de modelos de linguagem de grande escala para resumo, comparação e análise que levariam horas a fazer manualmente.

O padrão mais simples é converter os seus dados extraídos numa tabela Markdown ou num prompt estruturado e, em seguida, enviá-los para uma API LLM:

def build_prompt(products):
    lines = ["| Title | Price | Rating |", "|---|---|---|"]
    for p in products[:20]:
        lines.append(
            f"| {p['title'][:60]} | {p['price']} | {p['rating']} |"
        )
    table = "\n".join(lines)
    prompt = (
        "Below is a table of Amazon products. "
        "Summarize the price range, identify the top-rated option, "
        "and note any patterns in pricing vs. ratings.\n\n"
        f"{table}"
    )
    return prompt

Também pode alimentar JSON diretamente como contexto para um pipeline de geração aumentada por recuperação (RAG). Por exemplo, descarregue o catálogo de produtos extraídos para um armazenamento de vetores e, em seguida, permita que os utilizadores façam perguntas como «Qual é o hub USB-C abaixo de 30 dólares com as melhores avaliações?» e obtenham respostas fundamentadas e apoiadas em dados.

Algumas dicas práticas para dados da Amazon prontos para LLM:

• Trunque os títulos. Os títulos dos produtos da Amazon são notoriamente longos. Reduza-os para 60 a 80 caracteres para se manter dentro dos limites de tokens.
• Normalize os preços. Remova os símbolos monetários e converta-os em números decimais antes de os introduzir em prompts analíticos.
• Agrupe os pedidos. Se tiver centenas de produtos, divida-os em grupos de 20 a 30 por prompt para evitar limites da janela de contexto.

Esta combinação de web scraping e análise LLM é um poderoso diferenciador para equipas que fazem inteligência competitiva ou extração de dados de produtos da Amazon em grande escala.

Mesmo com um scraper sólido, as coisas podem correr mal. Aqui estão os problemas mais comuns que irá encontrar ao fazer scraping de páginas de produtos da Amazon e como resolvê-los.

Respostas 403 Forbidden. Isto significa normalmente que o WAF da Amazon sinalizou o seu pedido. Verifique primeiro o seu User-Agent cabeçalho primeiro. Se estiver em falta ou for obviamente sintético (como python-requests/2.28), substitua-o por uma string de navegador realista. Se o 403 persistir, é provável que o seu IP esteja bloqueado. Mude para um proxy ou adicione um intervalo maior entre as solicitações.

Loops de CAPTCHA. Se cada pedido devolver uma página de CAPTCHA em vez de resultados de produtos, o seu IP ou sessão foi sinalizado. Alternar para um IP residencial novo geralmente resolve isto. Existem serviços programáticos de resolução de CAPTCHA, mas acrescentam latência e custos.

Seletores vazios (valores «None» em todo o lado). Isto sinaliza frequentemente que a Amazon serviu uma página renderizada por JavaScript e que a sua requests.get() chamada capturou apenas o shell HTML pré-renderizado. Verifique imprimindo len(response.text). Se a resposta for suspeitamente curta (menos de 50 KB para uma página de pesquisa), é provável que esteja a encontrar um layout dependente de JS. Um navegador headless ou uma API de scraping com renderização JavaScript pode resolver isto.

Seletores desatualizados após uma alteração de layout. A Amazon alterna classes CSS e estruturas DOM periodicamente. Se um scraper que funcionava na semana passada de repente devolver dados vazios, inspecione uma página atualizada no DevTools e atualize os seus seletores. Crie seletores em torno de data- atributos (como data-asin e data-component-type) é mais resiliente do que basear-se em nomes de classes.

• Decida a sua abordagem desde o início. Os scrapers DIY em Python oferecem controlo total, as APIs de scraping eliminam a sobrecarga operacional e as ferramentas sem código atendem a quem não é programador. Escolha a ferramenta de acordo com as competências da sua equipa e o orçamento de manutenção.
• Respeite as defesas da Amazon. Cabeçalhos realistas, cadência de pedidos e rotação de proxies não são opcionais. Ignore-os e passará mais tempo a depurar bloqueios do que a escrever lógica de análise.
• Crie seletores com base em atributos estáveis. Foque-se data-asin e data-component-type em vez de nomes de classes voláteis. Isto mantém o seu scraper a funcionar apesar das frequentes atualizações de layout da Amazon.
• Exporte cedo, exporte frequentemente. Grave os dados extraídos em CSV ou JSON após cada lote de paginação. Se uma solicitação posterior falhar, não perderá tudo o que já recolheu.
• A integração com LLM multiplica o valor. Os dados de produtos extraídos tornam-se significativamente mais úteis quando os canaliza para fluxos de trabalho de resumo, comparação ou RAG.

Não, não explicitamente. As Condições de Utilização da Amazon proíbem o acesso automatizado ao site. No entanto, tribunais em algumas jurisdições determinaram que a extração de dados disponíveis publicamente pode não violar as leis de fraude informática. O panorama jurídico é complexo e varia de país para país, por isso consulte um advogado se pretender fazer scraping em escala comercial.

Utilize cabeçalhos de navegador realistas (especialmente User-Agent), adicione intervalos de pelo menos 1 a 2 segundos entre os pedidos e alterne endereços IP com um conjunto de proxies residenciais. Evite fazer scraping em rajadas rápidas a partir de um único IP e considere aleatorizar os intervalos entre os pedidos para imitar os padrões de navegação humanos.

Sim. Várias plataformas de scraping visual oferecem interfaces do tipo «apontar e clicar» com modelos pré-construídos para a Amazon. Configure os seletores através de uma extensão do navegador ou de uma interface de utilizador web, e a ferramenta trata da gestão de pedidos e da exportação de dados. Estas opções funcionam melhor para extrações de dados mais pequenas e pontuais, em vez de pipelines automatizados em grande escala.

Requests e BeautifulSoup são a combinação padrão para a extração de HTML estático. Adicione lxml como backend de análise para um processamento mais rápido. Para páginas que dependem fortemente da renderização em JavaScript, o Playwright ou o Selenium com um navegador headless são mais adequados. O pandas é útil na fase de exportação para limpar e estruturar os dados recolhidos.

Extrair dados de produtos da Amazon é um daqueles projetos que parecem simples no papel e se tornam complicados rapidamente. A análise em si é simples: assim que se conhecem os seletores CSS corretos, o BeautifulSoup faz o trabalho pesado com apenas algumas linhas de código. O verdadeiro desafio está em tudo o que envolve a análise: obter uma resposta limpa que passe pela pilha anti-bot da Amazon, lidar com a paginação sem que o seu IP seja sinalizado e manter os seus seletores atualizados à medida que a plataforma evolui.

O fluxo de trabalho em Python abordado neste guia dá-lhe uma base sólida. Pode obter resultados de pesquisa, extrair títulos, preços, classificações, imagens e ASINs, paginar em várias páginas, exportar ficheiros CSV ou JSON limpos e até mesmo alimentar esses dados em pipelines de LLM para análise automatizada. Para projetos pontuais mais pequenos, essa abordagem «faça você mesmo» pode ser tudo o que precisa.

Para cargas de trabalho de produção onde o tempo de atividade é importante, considere transferir a camada de pedidos para um serviço como o WebScrapingAPI. Este serviço gere a rotação de proxies, a resolução de CAPTCHA e a lógica de repetição de tentativas por trás de um único ponto de extremidade, para que se possa concentrar nos dados em vez de na infraestrutura. O seu código de análise BeautifulSoup permanece exatamente o mesmo; apenas a etapa de obtenção muda.

Seja qual for o caminho que escolher, o segredo é começar com um plano claro: definir quais os atributos do produto de que necessita, decidir o formato de exportação e integrar o tratamento de erros desde o início. O catálogo da Amazon é uma mina de ouro de dados estruturados, se o abordar de forma metódica.