ChatGPT Web Scraping: Um Guia Prático

TL;DR:

• ChatGPT não busca páginas da web — ele analisa o texto que você fornece. O modelo não possui navegador, motor JavaScript e nenhum meio de contornar um desafio de acesso, então cada configuração funcional de "web scraping com ChatGPT" é composta por duas camadas: algo busca a página, o modelo extrai os campos.
• A camada de extração é genuinamente boa. Com as saídas estruturadas do SDK Python da OpenAI, você define um esquema Pydantic e chat.completions.parse retorna objetos validados — sem manutenção de seletores quando o layout da página muda.
• O limite é mensurável. Um simples GET HTTP em uma página demo renderizada por JavaScript retorna 0 elementos de citação; a mesma URL buscada através da API de Scraping Universal Scrapeless com js_render habilitado retorna todas as 10. Essa diferença é exatamente o que o modelo não consegue ultrapassar por conta própria.
• O design do esquema supera a esperteza do prompt. Campos nulos, tipos explícitos e uma página por chamada produzem extrações em que você pode confiar; prompts vagos produzem invenções confiantes.
• Saiba qual ferramenta você está usando. "Web scraping com ChatGPT" (este guia — o modelo como analisador) é o oposto de um scraper de ChatGPT, que captura as próprias respostas do ChatGPT como dados.
• Gratuito para começar. A camada de busca deste guia funciona no plano gratuito — crie sua chave de API em app.scrapeless.com.

O ChatGPT pode extrair dados de sites?

Não por si só. O ChatGPT é um modelo de linguagem: ele lê e produz texto, e não faz nenhuma das coisas que a camada de busca de um scraper faz — emitir solicitações, executar JavaScript, manter sessões ou responder a desafios anti-bot. Cole o texto da página nele e ele extrai campos de forma impressionante; aponte para uma URL e você está dependendo de qualquer ferramenta de busca que envolva o modelo naquele dia, que falha silenciosamente em páginas renderizadas ou protegidas.

Portanto, a arquitetura prática do web scraping com ChatGPT é sempre as mesmas duas camadas. Uma camada de busca recupera uma cópia fiel da página. Uma camada de extração — a API da OpenAI com um esquema — transforma essa cópia em registros estruturados. Este guia constrói primeiro a camada de extração, porque é aí que o ChatGPT conquista seu lugar, e depois demonstra o modo de falha da camada de busca e sua correção com um exemplo ao vivo e reproduzível.

Uma desambiguação antes do código, porque a palavra-chave é genuinamente ambígua: este guia usa o ChatGPT como o cérebro do scraper. O trabalho inverso — capturando as próprias respostas do ChatGPT e suas citações como dados — é uma ferramenta totalmente diferente, coberta pelo guia da API Scraper do ChatGPT e pelo explicador mais amplo sobre scrapers LLM.

Instalação

Dois pacotes cobrem ambas as camadas — o SDK da OpenAI para extração e requests para HTTP. As versões aqui são aquelas contra as quais este guia foi escrito (openai 2.34.0):

pip install "openai==2.34.0" requests

Configuração

Ambas as camadas autenticam a partir do ambiente, então nenhuma chave vive no código-fonte:

export OPENAI_API_KEY="sk-sua_chave_openai"
export SCRAPELESS_API_KEY="sk_sua_chave_scrapeless"

Implementação básica: extração com esquema em primeiro lugar

O SDK atual da OpenAI faz extração estruturada em uma chamada: defina o registro como um modelo Pydantic, passe-o como response_format, e chat.completions.parse retorna instâncias dele. O esquema carrega a confiabilidade. O modelo é restringido aos nomes de campos e tipos que você declarou — o mesmo estilo de contrato especificação JSON Schema formaliza — então a qualidade da saída deixa de depender de quão cuidadosamente você implorou no prompt.

Nota: Este bloco precisa de um OPENAI_API_KEY com crédito de API — o único pré-requisito que este guia não assume, então as chamadas de extração são mostradas sem saída capturada e seu formato de resultado é descrito abaixo. A camada de busca que se segue funciona de verdade apenas com uma chave Scrapeless.

# extract.py — ChatGPT como a camada de extração (requer OPENAI_API_KEY)
from openai import OpenAI
from pydantic import BaseModel


class Quote(BaseModel):
    text: str
    author: str
    tags: list[str]


class QuotePage(BaseModel):
    quotes: list[Quote]


client = OpenAI()  # lê OPENAI_API_KEY do ambiente
page_html = open("page.html", encoding="utf-8").read()

completion = client.chat.completions.parse(
    model="gpt-4.1-mini-2025-04-14",
    messages=[
        {
            "role": "system",
            "content": "Extraia cada citação da página. "
            "Use nulo para nada — omita uma citação completamente em vez de inventar campos.",
        },
```json
{"função": "usuário", "conteúdo": page_html},
    ],
    formato_resposta=QuotePage,
)

página = conclusão.escolhas[0].mensagem.parsed
print(f"extraído {len(página.citações)} citações")

Em uma página analisada, isso retorna um QuotePage cuja lista .citações contém uma Quote validada por registro — objetos Python tipados, não uma string que você ainda precisa de json.loads e defender. Os parâmetros e regras de esquema atuais estão em o guia de saídas estruturadas da OpenAI.

Padrões avançados

Três hábitos separam um extrator confiável de uma demonstração:

• Torne a ausência representável. Se um campo pode estar ausente na página real, digite-o como str | None e informe isso na mensagem do sistema. Um esquema com apenas strings obrigatórias força o modelo a preencher lacunas, e ele fará isso.
• Dê ao modelo menos página. O chrome HTML custa tokens e convida à distração. Se você puder isolar o contêiner de conteúdo — ou buscar a página como markdown em vez de HTML — a extração fica mais barata e mais precisa ao mesmo tempo.
• Mantenha uma página por chamada. Agrupar dez páginas em um único prompt economiza solicitações e compromete a correção: os registros se misturam entre os limites das páginas. O loop pertence ao Python, não ao prompt.

Há também uma segunda forma, mais antiga, de usar o ChatGPT para scraping: peça para ele escrever um script baseado em seletores para você e, em seguida, execute esse script em cada página. Continue sendo a escolha certa para trabalho em grande volume em um layout estável — o código gerado é executado gratuitamente após a primeira página — mas você o revisa como qualquer código que não escreveu, e herda todo limite da camada de busca na próxima seção.

O limite honesto: ChatGPT não pode buscar a página

Tudo acima assumiu que page.html existe e é fiel. Essa suposição é onde a extração apenas com ChatGPT quebra, e a quebra é reprodutível. Um simples GET HTTP retorna os bytes que o servidor envia — de acordo com a especificação de semântica HTTP, uma representação do recurso, não a página que um navegador construiria a partir dela. Em uma página renderizada em JavaScript, esses são documentos muito diferentes:

# plain_fetch.py — o que um GET simples realmente vê em uma página renderizada em JS
import requests

url = "https://quotes.toscrape.com/js/"
resp = requests.get(url, timeout=60)
html = resp.text
print(f"status {resp.status_code} | {len(html):,} caracteres")
print("elementos de citação no HTML:", html.count('<span class="text"'))

A execução imprime status 200 — uma solicitação perfeitamente bem-sucedida — e 0 elementos de citação, porque nesta página de demonstração as citações existem apenas dentro de uma variável de script até que um motor JavaScript construa o DOM. Passe este HTML para o extrator acima e o melhor modelo possível não extrai nada, ou pior, adivinha.

A solução é renderizar antes de extrair. A Universal Scraping API aceita a mesma URL em um POST, executa a página no servidor com js_render ativado e retorna o DOM que um leitor veria — desbloqueio e roteamento proxy incluídos, nada para executar localmente:

# rendered_fetch.py — a mesma URL, renderizada no servidor antes da extração
import os

import requests

resp = requests.post(
    "https://api.scrapeless.com/api/v1/unlocker/request",
    headers={
        "Content-Type": "application/json",
        "x-api-token": os.environ["SCRAPELESS_API_KEY"],
    },
    json={
        "ator": "unlocker.webunlocker",
        "input": {"url": "https://quotes.toscrape.com/js/", "method": "GET", "js_render": True},
    },
    timeout=120,
)
resp.raise_for_status()
html = resp.json().get("data", "")
print(f"página renderizada: {len(html):,} caracteres")
print("elementos de citação no HTML:", html.count('<span class="text"'))

with open("page.html", "w", encoding="utf-8") as f:
    f.write(html)

Mesma URL, e a execução imprime 10 elementos de citação em 8.940 caracteres de HTML renderizado — o arquivo que a camada de extração precisava o tempo todo. As duas impressões lado a lado são o argumento completo: 0 elementos de citação na busca simples, 10 na renderizada. Encadeie os dois scripts e você terá o padrão de trabalho: renderizar através do Scrapeless, extrair com o ChatGPT.

Obtenha sua chave de API no plano gratuito: app.scrapeless.com

Resolução de problemas

• O modelo retorna prosa em vez de JSON. Você está na chamada simples create — mude para chat.completions.parse com um modelo response_format, que restringe a saída no nível da API em vez de pedir gentilmente.
• Os campos retornam preenchidos que deveriam estar vazios. Torne o campo opcional no esquema e declare a regra de nulos na mensagem do sistema. A falha está no contrato, não no humor do modelo.
• A extração está correta em algumas páginas, vazia em outras. Compare o que você realmente buscou, não o que o navegador mostra — conte um elemento conhecido no HTML buscado da maneira que o script de busca simples faz. Zero correspondências significam um problema de renderização ou acesso, e você o corrige na camada de busca (js_render, ou um país de saída diferente) em vez de no prompt.
• Os custos de tokens aumentam com o volume. Reduza a página ao seu container de conteúdo antes da chamada, ou extraia de markdown em vez de HTML bruto. Para layouts de alto volume e estáveis, deixe o modelo escrever um script de seletor uma vez e gaste tokens apenas quando o layout mudar.

Conclusão

O ChatGPT mudou qual metade da extração é difícil. A extração — a parte que costumava significar seletores frágeis — agora é um esquema e uma chamada de SDK. A busca — a parte que o modelo não pode fazer — ainda decide se há algo real para extrair, e a demonstração de 0 versus 10 acima é como essa fronteira se parece na prática. Construa as duas camadas separadamente, verifique a busca antes de pagar pela extração, e a combinação é um extrator que sobrevive a redesigns.

Pronto para alimentar seu extrator com páginas reais?

A camada de busca neste guia é uma POST por página na Universal Scraping API — planos e volumes de solicitação estão na página de preços, e a documentação do desenvolvedor cobre todos os parâmetros que unlocker.webunlocker aceita. Crie uma chave no plano gratuito em app.scrapeless.com e execute novamente os dois scripts de busca você mesmo.

FAQ

P: O ChatGPT pode raspar sites diretamente?

Não. O modelo não pode emitir solicitações HTTP, executar JavaScript ou passar verificações anti-bot — ele extrai de texto que algo mais buscou. Produtos de chat para consumidores às vezes envolvem o modelo com uma ferramenta de navegação, mas essa ferramenta é de pequeno porte e bloqueada por muitos sites, razão pela qual as configurações de produção combinam o modelo com uma camada de busca dedicada.

P: Raspar com o ChatGPT é legal?

A camada de extração não muda as regras da camada de coleta. Raspe apenas páginas públicas, respeite os termos do site e as diretrizes de robôs definidas pelo Protocolo de Exclusão de Robôs, mantenha volumes limitados e trate quaisquer dados pessoais de acordo com as leis de privacidade que se aplicam a você — as mesmas obrigações para qualquer extrator, além dos termos de uso do seu provedor de modelo.

P: Quando um extrator de seletor tradicional ainda é a melhor escolha?

Em alto volume em layouts estáveis. Uma chamada LLM custa tokens em cada página; um script de seletor não custa nada após ser escrito. A divisão prática: use o modelo onde os layouts variam ou mudam com frequência, e código de seletor gerado e revisado onde um layout se repete milhares de vezes.

P: Como isso é diferente de um "extrator ChatGPT"?

Direção. Este guia aponta o modelo para a web — o ChatGPT é o analisador. Um extrator ChatGPT aponta um extrator para o ChatGPT — ele captura as respostas, citações e resultados do produto do assistente como dados estruturados. O Scrapeless envia isso como um ator; o guia da API do extrator ChatGPT mencionado na introdução cobre isso.

P: Qual modelo da OpenAI eu devo usar para extração?

Comece com um modelo pequeno e atualizado e só aumente se a qualidade da extração exigir. Saídas estruturadas restringem a forma da resposta, independentemente do tamanho do modelo, então os níveis menores lidam bem com esquemas bem definidos em entradas limpas — gaste a economia em buscar mais páginas em vez disso.