Como construir um web scraper com IA em Python: transforme qualquer página em um mecanismo de perguntas e respostas

Por que um scraper “inteligente”?

Web scraping é o processo de coletar informações de sites automaticamente. Um scraper comum extrai texto bruto, elementos HTML ou a página inteira. Mas, quando você está construindo agentes de IA ou aplicações com modelos de linguagem (LLMs), mandar a página inteira para o modelo raramente é a melhor abordagem.

O caminho mais eficiente é limpar a página, convertê-la em Markdown e então usar um LLM para entender o conteúdo e devolver apenas a resposta que o usuário precisa. O resultado fica mais limpo, mais legível e mais fácil de integrar em outros fluxos — e reduz o consumo de tokens, porque você deixa de enviar menus, botões, scripts, rodapés e conteúdo repetido para o modelo.

Neste guia, baseado no tutorial de Abid Ali Awan (KDnuggets), você vai construir um web scraper de IA simples em Python usando Jupyter Notebook. Ele busca uma página, limpa o HTML, converte para Markdown, aceita uma pergunta e devolve uma resposta em Markdown baseada no conteúdo.

Prós e contras de construir o próprio scraper

✅ O que você ganha:

• Controle total sobre o que é enviado ao LLM, reduzindo custo de tokens;
• Saída em Markdown limpo, fácil de salvar ou repassar a outro fluxo;
• Pipeline pequeno e fácil de entender, reutilizável em API, chatbot ou agente;
• Zero dependência de serviços externos de scraping pagos.

⚠️ O que você NÃO ganha:

• Robustez contra sites com anti-bot ou que exigem renderização JavaScript;
• Manutenção gratuita — páginas quebram e os seletores precisam de ajustes;
• Escala de crawler profissional (há custos de servidor e de chamadas ao LLM).

Antes de construir, vale olhar ferramentas prontas como Firecrawl, Exa ou Olostep. Para tarefas pequenas e específicas, a solução caseira costuma compensar.

Requisitos

Passo 1 — Instalar as dependências

Comece instalando os pacotes necessários:

!pip install requests beautifulsoup4 markdownify openai ftfy python-dotenv

Cada pacote tem um papel: requests busca a página, BeautifulSoup remove elementos ruidosos do HTML, markdownify converte HTML em Markdown, openai responde à pergunta, ftfy corrige textos com encoding quebrado e python-dotenv carrega a chave da API com segurança.

Passo 2 — Configurar a chave da API

Crie um arquivo .env na mesma pasta do notebook:

OPENAI_API_KEY=your_api_key_here

Depois carregue no notebook e defina o modelo. O tutorial usa um modelo menor porque a tarefa não exige raciocínio pesado — basta ler o conteúdo limpo e responder de forma focada:

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

if not os.getenv("OPENAI_API_KEY"):
    raise ValueError("OPENAI_API_KEY is missing. Add it to your .env file first.")

MODEL_NAME = "gpt-5.4-nano"

Passo 3 — Buscar a página

A primeira função baixa o HTML bruto. O User-Agent informa ao site de onde vem a requisição (alguns bloqueiam requisições sem ele), e o timeout evita esperar indefinidamente. O raise_for_status() interrompe o código se a página retornar erro 404 ou 500:

def fetch_page(url: str) -> str:
    headers = {"User-Agent": "SimpleAIScraper/1.0"}
    response = requests.get(url, headers=headers, timeout=15)
    response.raise_for_status()
    return response.text

Passo 4 — Limpar o HTML

O HTML bruto traz scripts, estilos, menus, formulários e popups que só desperdiçam tokens. O clean_html usa o BeautifulSoup para remover tags ruidosas e, depois, varre as classes e IDs procurando palavras como “popup”, “cookie”, “navbar” e “newsletter”:

def clean_html(html):
    html = fix_text(html)
    soup = BeautifulSoup(html, "html.parser")
    for tag in soup(["script", "style", "noscript", "svg", "img",
                     "iframe", "nav", "header", "footer", "aside",
                     "form", "button"]):
        tag.decompose()
    noise_words = ["popup", "cookie", "navbar", "menu", "footer",
                   "subscribe", "newsletter", "modal", "signup", "login"]
    for tag in soup.find_all(True):
        class_text = " ".join(tag.get("class", [])).lower()
        if any(w in class_text for w in noise_words):
            tag.decompose()
    return str(soup.body or soup)

Passo 5 — Converter para Markdown

Markdown é mais fácil de ler, salvar e entender pelo LLM do que HTML bruto. A conversão usa markdownify e remove imagens, espaços extras e linhas repetidas de navegação:

from markdownify import markdownify as md

def html_to_markdown(html):
    text = md(html, heading_style="ATX", bullets="-")
    text = fix_text(text)
    text = re.sub(r"!\[.*?\]\(.*?\)", "", text)  # remove imagens
    return text

Passo 6 — Perguntar à página com o LLM

O coração do scraper é o prompt. Ele instrui o modelo a responder apenas com o conteúdo fornecido, sem inventar detalhes, e a devolver Markdown limpo:

def answer_query_from_page(markdown_text, user_query):
    prompt = f"You are an AI web scraping assistant. " \
             f"Answer the user's query using ONLY the page content. " \
             f"Do not invent missing details. Return clean Markdown. " \
             f"Query: {user_query}\n\nPage:\n{markdown_text}"
    response = client.responses.create(model=MODEL_NAME, input=prompt)
    return response.output_text

Passo 7 — Juntar tudo

A função final conecta o pipeline inteiro — buscar, limpar, converter e responder — em uma única chamada:

def ai_web_scraper(url, user_query):
    raw_html = fetch_page(url)
    cleaned = clean_html(raw_html)
    md = html_to_markdown(cleaned)
    return answer_query_from_page(md, user_query)

result = ai_web_scraper("https://www.olostep.com/", "What does this company do?")
display(Markdown(result))

Em poucos segundos, você recebe uma resposta em Markdown focada e pronta para salvar em arquivo ou usar em outro fluxo.

Troubleshooting — erros comuns

• ❌ “OPENAI_API_KEY is missing”: o arquivo .env não está na pasta certa ou o load_dotenv() não foi chamado. Confirme o caminho e a grafia da variável.
• ❌ 404/500 ao buscar a página: o site pode bloquear o User-Agent padrão. Troque o header por um valor de navegador real.
• ❌ Resposta cheia de ruído (menus, rodapés): a lista noise_words não cobre o site. Adicione as classes e IDs específicos daquela página.
• ❌ Resposta “vazia” ou genérica: o modelo não encontrou a resposta no Markdown. Verifique se a conversão preservou o conteúdo útil ou ajuste o prompt.
• ❌ Erro de cota/billing da OpenAI: a conta precisa de créditos pré-pagos. Adicione créditos ou troque o modelo no painel.

FAQ

Preciso de um modelo de raciocínio pesado? Não. A tarefa é simples — ler e responder com base na página. Um modelo pequeno reduz custo e latência.

Posso usar outra API além da OpenAI? Sim. Basta trocar o cliente e o modelo por um provedor compatível (Anthropic, Groq, etc.).

Funciona com sites que exigem JavaScript? Não diretamente. Para esses casos, use ferramentas com renderização (como Firecrawl ou Playwright).

É legal fazer scraping? Depende dos termos de uso do site e da legislação local. Verifique o robots.txt e as políticas antes de raspar em escala.

Como reutilizo isso em produção? Embrulhe a função ai_web_scraper em uma API (FastAPI/Flask) ou a transforme em uma ferramenta para um agente.