Web Scraping com LLaMA 3: Transforme qualquer site em JSON estruturado (Guia 2025)

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

wait = WebDriverWait(driver, 15)
product_container = wait.until(
    EC.presence_of_element_located((By.ID, "ppd"))
)

# Extract the full HTML of the product container
page_html = product_container.get_attribute("outerHTML")

Essa abordagem:

• Espera por conteúdo renderizado por JavaScript (como preços e classificações)
• Direciona apenas a seção relevante do produto – ignorando cabeçalhos, rodapés e barras laterais

Confira nosso guia completo sobre como extrair dados de produtos da Amazon em Python.

Etapa 4 – Converter HTML em Markdown

As páginas da Amazon contêm HTML profundamente aninhado que é ineficiente para os LLMs processarem. Uma otimização importante é a conversão desse HTML em Markdown limpo, o que reduz drasticamente a contagem de tokens e melhora a compreensão.

Quando você executar o script completo, serão gerados dois arquivos: amazon_page.html e amazon_page.md. Tente colar ambos na ferramenta Token Calculator para comparar suas contagens de tokens.

Conforme mostrado abaixo, o HTML contém cerca de 270.000 tokens:

A versão Markdown? Apenas ~11.000 tokens:

Essa redução de 96% leva a:

• Eficiência de custos – menos tokens significam custos menores de API ou computação
• Processamento mais rápido – menos dados de entrada = respostas mais rápidas do LLM
• Maior precisão – Um texto mais limpo e plano ajuda o modelo a extrair dados estruturados com mais precisão

Leia mais sobre por que os agentes de IA preferem Markdown a HTML.

Veja como fazer a conversão em Python:

from markdownify import markdownify as md

clean_text = md(page_html, heading_style="ATX")

Etapa 5 – Criar o prompt de extração de dados

Um prompt bem estruturado é essencial para obter uma saída JSON consistente e limpa do LLM. Abaixo está um prompt que instrui o modelo a retornar somente JSON válido em um formato predefinido:

PROMPT = (
    "You are an expert Amazon product data extractor. Your task is to extract product data from the provided content. "
    "Return ONLY valid JSON with EXACTLY the following fields and formats:\n\n"
    "{\n"
    '  "title": "string – the product title",\n'
    '  "price": number – the current price (numerical value only)",\n'
    '  "original_price": number or null – the original price if available,\n'
    '  "discount": number or null – the discount percentage if available,\n'
    '  "rating": number or null – the average rating (0–5 scale),\n'
    '  "review_count": number or null – total number of reviews,\n'
    '  "description": "string – main product description",\n'
    '  "features": ["string"] – list of bullet point features,\n'
    '  "availability": "string – stock status",\n'
    '  "asin": "string – 10-character Amazon ID"\n'
    "}\n\n"
    "Return ONLY the JSON without any additional text."
)

Etapa 6 – Chamar a API do LLM

Com o Ollama em execução local, você pode enviar o texto do Markdown para a instância do LLaMA por meio de sua API HTTP:

import requests
import json

response = requests.post(
    "<http://localhost:11434/api/generate>",
    json={
        "model": "llama3.1:8b",
        "prompt": f"{PROMPT}\n\n{clean_text}",
        "stream": False,
        "format": "json",
        "options": {
            "temperature": 0.1,
            "num_ctx": 12000,
        },
    },
    timeout=250,
)

raw_output = response.json()["response"].strip()
product_data = json.loads(raw_output)

O que cada opção faz:

• temperatura – Defina como 0,1 para obter uma saída determinística (ideal para formatação JSON)
• num_ctx – Define o comprimento máximo do contexto. 12.000 tokens são suficientes para a maioria das páginas de produtos da Amazon
• stream – Quando False, a API retorna a resposta completa após o processamento
• format – Especifica o formato de saída (JSON)
• model – Indica a versão do LLaMA a ser usada

Como o Markdown convertido normalmente contém cerca de 11.000 tokens, é importante definir a janela de contexto(num_ctx) de acordo. Embora o aumento desse valor permita lidar com entradas mais longas, ele também aumenta o uso da RAM e torna o processamento mais lento. Aumente o limite de contexto somente se as páginas de seus produtos forem especialmente longas ou se você tiver os recursos de computação para suportá-lo.

Etapa 7 – Salvar os resultados

Por fim, salve os dados estruturados do produto em um arquivo JSON:

with open("product_data.json", "w", encoding="utf-8") as f:
    json.dump(product_data, f, indent=2, ensure_ascii=False)

Etapa 8: Executar o script

Para executar seu raspador, forneça um URL de produto da Amazon e chame sua função de raspagem:

if __name__ == "__main__":
    url = "<https://www.amazon.com/Black-Office-Chair-Computer-Adjustable/dp/B00FS3VJAO>"

    # Call your function to scrape and extract product data
    scrape_amazon_product(url)

Etapa 9 – Exemplo de código completo

Abaixo está o script Python completo que combina todas as etapas em um fluxo de trabalho coeso e de ponta a ponta:

import json
import logging
import time
from typing import Final, Optional, Dict, Any

import requests
from markdownify import markdownify as html_to_md
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
from webdriver_manager.chrome import ChromeDriverManager

# Configuration constants
LLM_API_CONFIG: Final[Dict[str, Any]] = {
    "endpoint": "<http://localhost:11434/api/generate>",
    "model": "llama3.1:8b",
    "temperature": 0.1,
    "context_window": 12000,
    "stream": False,
    "timeout_seconds": 220,
}

DEFAULT_PRODUCT_DATA: Final[Dict[str, Any]] = {
    "title": "",
    "price": 0.0,
    "original_price": None,
    "discount": None,
    "rating": None,
    "review_count": None,
    "description": "",
    "features": [],
    "availability": "",
    "asin": "",
}

PRODUCT_DATA_EXTRACTION_PROMPT: Final[str] = (
    "You are an expert Amazon product data extractor. Your task is to extract product data from the provided content. "
    "Return ONLY valid JSON with EXACTLY the following fields and formats:\n\n"
    "{\n"
    '  "title": "string - the product title",\n'
    '  "price": number - the current price (numerical value only),\n'
    '  "original_price": number or null - the original price if available,\n'
    '  "discount": number or null - the discount percentage if available,\n'
    '  "rating": number or null - the average rating (0-5 scale),\n'
    '  "review_count": number or null - total number of reviews,\n'
    '  "description": "string - main product description",\n'
    '  "features": ["string"] - list of bullet point features,\n'
    '  "availability": "string - stock status",\n'
    '  "asin": "string - 10-character Amazon ID"\n'
    "}\n\n"
    "Return ONLY the JSON without any additional text."
)

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.StreamHandler()],
)

def initialize_web_driver(headless: bool = True) -> webdriver.Chrome:
    """Initialize and return a configured Chrome WebDriver instance."""
    options = Options()
    if headless:
        options.add_argument("--headless=new")

    service = Service(ChromeDriverManager().install())
    return webdriver.Chrome(service=service, options=options)

def fetch_product_container_html(product_url: str) -> Optional[str]:
    """Retrieve the HTML content of the Amazon product details container."""
    driver = initialize_web_driver()
    try:
        logging.info(f"Accessing product page: {product_url}")
        driver.set_page_load_timeout(15)
        driver.get(product_url)

        # Wait for the product container to appear
        container = WebDriverWait(driver, 5).until(
            EC.presence_of_element_located((By.ID, "ppd"))
        )
        return container.get_attribute("outerHTML")
    except Exception as e:
        logging.error(f"Error retrieving product details: {str(e)}")
        return None
    finally:
        driver.quit()

def extract_product_data_via_llm(markdown_content: str) -> Optional[Dict[str, Any]]:
    """Extract structured product data from markdown text using LLM API."""
    try:
        logging.info("Extracting product data via LLM API...")
        response = requests.post(
            LLM_API_CONFIG["endpoint"],
            json={
                "model": LLM_API_CONFIG["model"],
                "prompt": f"{PRODUCT_DATA_EXTRACTION_PROMPT}\n\n{markdown_content}",
                "format": "json",
                "stream": LLM_API_CONFIG["stream"],
                "options": {
                    "temperature": LLM_API_CONFIG["temperature"],
                    "num_ctx": LLM_API_CONFIG["context_window"],
                },
            },
            timeout=LLM_API_CONFIG["timeout_seconds"],
        )
        response.raise_for_status()

        raw_output = response.json()["response"].strip()
        # Clean JSON output if it's wrapped in markdown code blocks
        if raw_output.startswith(("```json", "```")):
            raw_output = raw_output.split("```")[1].strip()
            if raw_output.startswith("json"):
                raw_output = raw_output[4:].strip()

        return json.loads(raw_output)

    except requests.exceptions.RequestException as e:
        logging.error(f"LLM API request failed: {str(e)}")
        return None
    except json.JSONDecodeError as e:
        logging.error(f"Failed to parse LLM response: {str(e)}")
        return None
    except Exception as e:
        logging.error(f"Unexpected error during data extraction: {str(e)}")
        return None

def scrape_amazon_product(
    product_url: str, output_file: str = "product_data.json"
) -> None:
    """Scrape an Amazon product page and save extracted data along with HTML and Markdown to files."""
    start_time = time.time()
    logging.info(f"Starting scrape for: {product_url}")

    # Step 1: Fetch product page HTML
    product_html = fetch_product_container_html(product_url)
    if not product_html:
        logging.error("Failed to retrieve product page content")
        return

    # Optional: save HTML for debugging
    with open("amazon_product.html", "w", encoding="utf-8") as f:
        f.write(product_html)

    # Step 2: Convert HTML to Markdown
    product_markdown = html_to_md(product_html)

    # Optional: save Markdown for debugging
    with open("amazon_product.md", "w", encoding="utf-8") as f:
        f.write(product_markdown)

    # Step 3: Extract structured data via LLM
    product_data = (
        extract_product_data_via_llm(product_markdown) or DEFAULT_PRODUCT_DATA.copy()
    )

    # Step 4: Save JSON results
    try:
        with open(output_file, "w", encoding="utf-8") as json_file:
            json.dump(product_data, json_file, indent=2, ensure_ascii=False)
        logging.info(f"Successfully saved product data to {output_file}")
    except IOError as e:
        logging.error(f"Failed to save JSON results: {str(e)}")

    elapsed_time = time.time() - start_time
    logging.info(f"Completed in {elapsed_time:.2f} seconds")

if __name__ == "__main__":
    # Example usage
    test_url = (
        "<https://www.amazon.com/Black-Office-Chair-Computer-Adjustable/dp/B00FS3VJAO>"
    )
    scrape_amazon_product(test_url)

Quando o script é executado com êxito, ele salva os dados extraídos do produto em um arquivo chamado product_data.json. A saída será semelhante a esta:

{
    "title": "Home Office Chair Ergonomic Desk Chair Mesh Computer Chair with Lumbar Support Armrest Executive Rolling Swivel Adjustable Mid Back Task Chair for Women Adults, Black",
    "price": 36.98,
    "original_price": 41.46,
    "discount": 11,
    "rating": 4.3,
    "review_count": 58112,
    "description": 'Office chair comes with all hardware and tools, and is easy to assemble in about 10–15 minutes. The high-density sponge cushion offers flexibility and comfort, while the mid-back design and rectangular lumbar support enhance ergonomics. All components are BIFMA certified, supporting up to 250 lbs. The chair includes armrests and an adjustable seat height (17.1"–20.3"). Its ergonomic design ensures a perfect fit for long-term use.',
    "features": [
        "100% mesh material",
        "Quick and easy assembly",
        "High-density comfort seat",
        "BIFMA certified quality",
        "Includes armrests",
        "Ergonomic patented design",
    ],
    "availability": "In Stock",
    "asin": "B00FS3VJAO",
}

Pronto! O HTML bagunçado se transforma em JSON limpo – essa é a mágica dos LLMs em raspagem da Web.

Superação das medidas antibot

Ao executar o bot de raspagem da Web acima, você provavelmente encontrará as medidas anti-bot da Amazon, como os desafios CAPTCHA:

Isso destaca uma limitação importante: Embora nosso fluxo de trabalho baseado em LLaMA seja excelente na análise de HTML, o acesso a esse conteúdo ainda é um desafio em sites com proteções anti-bot avançadas.

Para superar isso, você precisará contornar os CAPTCHAs da Amazon e lidar com outros desafios de raspagem da Web.

É aí que entra o Scraping Browser da Bright Data, uma solução criada especificamente para lidar com as complexidades dos ambientes modernos da Web, incluindo o desbloqueio confiável até mesmo dos sites mais protegidos, onde as ferramentas tradicionais falham.

Saiba mais: Navegador de raspagem vs. navegadores sem cabeça

Por que usar o navegador Bright Data Scraping?

O Bright Data Scraping Browser é um navegador sem cabeça, baseado em nuvem, com infraestrutura de proxy integrada e recursos avançados de desbloqueio, desenvolvido especificamente para dimensionar projetos modernos de raspagem da Web. Ele faz parte da suíte de raspagem Bright Data Unlocker.

Veja por que os desenvolvedores e as equipes de dados o escolhem:

• Impressões digitais confiáveis de TLS e técnicas de evasão furtiva
• Rotação de IP integrada, alimentada por uma rede proxy de mais de 150 milhões de IPs
• Resolução automática de CAPTCHA
• Reduza a infraestrutura – Elimine as configurações de nuvem caras e a manutenção contínua
• Suporte nativo para Playwright, Puppeteer e Selenium
• Escalabilidade ilimitada para extração de grandes volumes de dados

A melhor parte? Você pode integrá-lo ao seu fluxo de trabalho existente com apenas algumas linhas de código.

Leia por que mais empresas estão mudando para a raspagem da Web baseada na nuvem.

Configuração do navegador de raspagem

Para começar a usar o Scraping Browser:

Crie uma conta na Bright Data (os novos usuários recebem um crédito de US$ 5 após adicionar um método de pagamento) e, no painel, vá para Proxies & Scraping e clique em Get started.

Crie uma nova zona (por exemplo, test_browser) e ative recursos como domínios Premium e solucionador de CAPTCHA.

Em seguida, copie o URL do Selenium do seu painel.

Modificando seu código para o navegador de raspagem

Atualize sua função initialize_web_driver para se conectar por meio do navegador de raspagem:

from selenium.webdriver import Remote
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver.chromium.remote_connection import ChromiumRemoteConnection

SBR_WEBDRIVER = "<https://username:password@host>:port"

def initialize_web_driver():
    options = ChromeOptions()
    sbr_connection = ChromiumRemoteConnection(SBR_WEBDRIVER, "goog", "chrome")
    driver = Remote(sbr_connection, options=options)
    return driver

É isso: seu raspador agora passa pela infraestrutura da Bright Data e lida com a Amazon e outros sistemas antibot com facilidade.

Explore recursos mais avançados na documentação do Navegador de raspagem.

Próximas etapas e soluções alternativas

Para ampliar os recursos de seu raspador acionado pelo LLaMA ou explorar outras implementações, considere as seguintes melhorias e alternativas.

• Tornar o script reutilizável: Permitir que o URL e o prompt sejam passados como argumentos de linha de comando para uso flexível
• Proteja suas credenciais: Armazene suas credenciais do navegador de raspagem em um arquivo .env e carregue-as com segurança usando python-dotenv
• Adicionar suporte a várias páginas: Implementar lógica para rastrear várias páginas e lidar com a paginação
• Extraia mais sites – Use os recursos antidetecção do navegador de extração para extrair outras plataformas de comércio eletrônico
• Extraia dados dos serviços do Google – Crie raspadores dedicados para o Google Flights, a Pesquisa Google e o Google Trends, ou use a API SERP da Bright Data para obter dados de pesquisa prontos para uso

Se você preferir soluções gerenciadas ou quiser explorar outros métodos orientados pelo LLM, as seguintes opções podem ser adequadas:

1. Raspagem com o Gemini
2. Raspagem com perplexidade
3. Crie um raspador de IA com o Crawl4AI e o DeepSeek

Conclusão

Este guia fornece uma base sólida para a criação de raspadores da Web resilientes usando o LLaMA 3. Ao combinar os recursos de raciocínio de modelos de linguagem grandes com ferramentas avançadas de raspagem, você pode extrair dados estruturados de sites complexos com o mínimo de esforço.

Evitar a detecção e o bloqueio é um dos maiores desafios da raspagem da Web. O Bright Data Scraping Browser aborda esse problema ao lidar automaticamente com a renderização dinâmica, a impressão digital e a proteção anti-bot. Ele faz parte de um conjunto mais amplo de ferramentas projetadas para dar suporte à extração de dados em escala:

• Serviços de proxy – Acesse mais de 150 milhões de IPs residenciais para contornar restrições geográficas
• APIs do Web Scraper – Extraia dados estruturados de mais de 100 sites populares por meio de pontos de extremidade dedicados
• API de desbloqueio da Web – Recupere HTML totalmente renderizado de qualquer URL, ignorando os sistemas antirrastreamento
• API SERP – Colete resultados de pesquisa em tempo real de todos os principais mecanismos de pesquisa

Inscreva-se hoje mesmo para testar gratuitamente o conjunto completo de ferramentas de raspagem e proxy da Bright Data!