ChatGPT Web Scraping: Una Guía Práctica

TL;DR:

• ChatGPT no obtiene páginas web: parsea el texto que le proporcionas. El modelo no tiene navegador, ni motor JavaScript, ni forma de superar un desafío de acceso, por lo que cada configuración funcional de "scraping web con ChatGPT" tiene dos capas: algo obtiene la página, el modelo extrae los campos.
• La capa de extracción es realmente buena. Con las salidas estructuradas del SDK de Python de OpenAI, defines un esquema Pydantic y chat.completions.parse devuelve objetos validados; no hay mantenimiento de selectores cuando el diseño de la página cambia.
• El límite es medible. Una simple solicitud HTTP GET en una página de demostración renderizada por JavaScript devuelve 0 elementos de cita; la misma URL obtenida a través de la API de Scraping Universal de Scrapeless con js_render habilitado devuelve todos los 10. Esa diferencia es exactamente lo que el modelo no puede cruzar por sí mismo.
• El diseño del esquema supera la ingeniosidad del aviso. Campos anulables, tipos explícitos y una página por llamada producen extracciones en las que puedes confiar; avisos vagos producen invenciones confiadas.
• Conoce qué herramienta estás sosteniendo. "Scraping web con ChatGPT" (esta guía: el modelo como parser) es lo opuesto a un scraper de ChatGPT, que captura las propias respuestas de ChatGPT como datos.
• Gratis para comenzar. La capa de obtención en esta guía se ejecuta en el plan gratuito: crea tu clave API en app.scrapeless.com.

¿Puede ChatGPT raspar sitios web?

No por sí mismo. ChatGPT es un modelo de lenguaje: lee y produce texto, y no hace ninguna de las cosas que hace la capa de obtención de un scraper: emitir solicitudes, ejecutar JavaScript, mantener sesiones o responder desafíos anti-bot. Pega el texto de la página en él y extrae campos de manera impresionante; si lo señalas a una URL, te estás apoyando en cualquier herramienta de obtención que envuelva el modelo ese día, la cual falla silenciosamente en páginas renderizadas o protegidas.

Por lo tanto, la arquitectura práctica del scraping web con ChatGPT siempre consiste en las mismas dos capas. Una capa de obtención recupera una copia fiel de la página. Una capa de extracción — la API de OpenAI con un esquema — convierte esa copia en registros estructurados. Esta guía construye primero la capa de extracción, porque ahí es donde ChatGPT gana su lugar, y luego demuestra el modo de falla de la capa de obtención y su solución con un ejemplo vivo y reproducible.

Una desambiguación antes del código, porque la palabra clave es genuinamente ambigua: esta guía usa a ChatGPT como el cerebro del scraper. El trabajo inverso —capturar las propias respuestas de ChatGPT y sus citas como datos— es una herramienta completamente diferente, cubierto por la guía de la API del Scraper de ChatGPT y la más amplia explicación sobre scrapers LLM.

Instalar

Dos paquetes cubren ambas capas: el SDK de OpenAI para la extracción y requests para HTTP. Las versiones aquí son las que esta guía fue escrita (openai 2.34.0):

pip install "openai==2.34.0" requests

Configurar

Ambas capas se autentican desde el entorno, por lo que ninguna clave vive en el código fuente:

export OPENAI_API_KEY="sk-tu_clave_openai"
export SCRAPELESS_API_KEY="sk_tu_clave_scrapeless"

Implementación básica: extracción primero con esquema

El SDK actual de OpenAI realiza extracción estructurada en una sola llamada: define el registro como un modelo Pydantic, pásalo como response_format, y chat.completions.parse devuelve instancias de él. El esquema lleva la fiabilidad. El modelo está limitado a los nombres y tipos de campo que declaraste; el mismo estilo de contrato que especificación de JSON Schema formaliza, por lo que la calidad de salida deja de depender de cuán cuidadosamente suplicaste en el aviso.

Nota: Este bloque necesita un OPENAI_API_KEY con crédito de API — el único requisito que esta guía no asume, por lo que las llamadas de extracción se muestran sin salida capturada y la forma de su resultado se describe a continuación. La capa de obtención que sigue se ejecuta de verdad solo con una clave de Scrapeless.

# extract.py — ChatGPT como la capa de extracción (requiere 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()  # lee OPENAI_API_KEY del entorno
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": "Extrae cada cita de la página. "
            "Usa null para nada — omite una cita por completo en lugar de inventar campos.",
        },

{"role": "user", "content": page_html},
],
response_format=QuotePage,
)

page = completion.choices[0].message.parsed
print(f"se extrajeron {len(page.quotes)} citas")

En una página parseada, esto devuelve un `QuotePage` cuya lista `.quotes` contiene una `Quote` validada por registro — objetos Python tipados, no una cadena que aún tengas que `json.loads` y defender. Los parámetros y reglas del esquema actuales están en <a href="https://developers.openai.com/api/docs/guides/structured-outputs" rel="nofollow"><strong>la guía de salidas estructuradas de OpenAI</strong></a>.

## Patrones avanzados

Tres hábitos separan un extractor confiable de una demostración:

- **Hacer que la ausencia sea representable.** Si un campo puede estar ausente en la página real, tipifícalo como `str | None` y así comunícalo en el mensaje del sistema. Un esquema con solo cadenas requeridas obliga al modelo a llenar vacíos, y lo hará.
- **Alimenta al modelo con menos página.** El chrome HTML cuesta tokens e invita a la distracción. Si puedes aislar el contenedor de contenido —o recuperar la página como markdown en lugar de HTML— la extracción se vuelve más barata y precisa al mismo tiempo.
- **Mantén una página por llamada.** Agrupar diez páginas en un solo aviso ahorra solicitudes y cuesta precisión: los registros se desdibujan a través de los límites de página. El bucle pertenece a Python, no al aviso.

También hay una segunda forma más antigua de usar ChatGPT para scraping: pídele que *escriba* un script basado en selectores para ti y luego ejecuta ese script en cada página. Sigue siendo la opción correcta para trabajos de alto volumen sobre un diseño estable, ya que el código generado se ejecuta de forma gratuita después de la primera página, pero lo revisas como cualquier código que no escribiste y hereda cada límite de capa de recuperación en la siguiente sección.

## El límite honesto: ChatGPT no puede recuperar la página

Todo lo anterior asumió que `page.html` existe y es fiel. Esa suposición es donde scraping solo con ChatGPT falla, y la ruptura es reproducible. Un GET HTTP simple devuelve los bytes que el servidor envía; según <a href="https://datatracker.ietf.org/doc/html/rfc9110" rel="nofollow"><strong>la especificación de semántica HTTP</strong></a>, una representación del recurso, no la página que un navegador construiría a partir de ello. En una página renderizada por JavaScript, estos son documentos muy diferentes:

```python
# plain_fetch.py — lo que un GET simple realmente ve en una página renderizada por JS
import requests

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

La ejecución imprime estado 200 — una solicitud perfectamente exitosa — y 0 elementos de cita, porque en esta página de demostración las citas existen solo dentro de una variable de script hasta que un motor JavaScript construye el DOM. Entrega este HTML al extractor anterior y el mejor modelo posible no extrae nada, o peor, adivina.

La solución es renderizar antes de extraer. La API de Scraping Universal toma la misma URL en un POST, ejecuta la página del lado del servidor con js_render habilitado y devuelve el DOM que un lector vería — desbloqueo y enrutamiento proxy incluidos, nada para ejecutar localmente:

# rendered_fetch.py — la misma URL, renderizada del lado del servidor antes de la extracción
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={
        "actor": "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 en el HTML:", html.count('<span class="text"'))

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

La misma URL, y la ejecución imprime 10 elementos de cita en 8,940 caracteres de HTML renderizado — el archivo que la capa de extracción necesitaba desde el principio. Las dos impresiones una al lado de la otra son todo el argumento: 0 elementos de cita en la recuperación simple, 10 en la renderizada. Encadena los dos scripts y tendrás el patrón funcional: renderizar a través de Scrapeless, extraer con ChatGPT.

Obtén tu clave API en el plan gratuito: app.scrapeless.com

Resolución de problemas

• El modelo devuelve prosa en lugar de JSON. Estás en la llamada create simple; cambia a chat.completions.parse con un modelo response_format, que restringe la salida a nivel de API en lugar de pedir amablemente.
• Los campos vuelven llenos que deberían estar vacíos. Haga que el campo sea opcional en el esquema y declare la regla de nulo en el mensaje del sistema. La falla está en el contrato, no en el estado de ánimo del modelo.
• La extracción es correcta en algunas páginas, vacía en otras. Compare lo que realmente obtuvo, no lo que el navegador le muestra: cuente un elemento conocido en el HTML obtenido de la misma manera que lo hace el script de plain-fetch. Cero coincidencias significa un problema de renderizado o acceso, y se soluciona en la capa de obtención (js_render, o un país de salida diferente) en lugar de en el aviso.
• Los costos de tokens aumentan con el volumen. Reduzca la página a su contenedor de contenido antes de la llamada, o extraiga de markdown en lugar de HTML bruto. Para diseños estables y de alto volumen, deje que el modelo escriba un script de selección una vez y gaste tokens solo cuando el diseño cambie.

Conclusión

ChatGPT cambió cuál mitad del raspado es difícil. La extracción — la parte que solía significar selectores frágiles — ahora es un esquema y una llamada de SDK. La obtención — la parte que el modelo no puede hacer — aún decide si hay algo real para extraer, y la demostración de 0 versus 10 anterior es lo que esa frontera parece en la práctica. Construya las dos capas por separado, verifique la obtención antes de pagar por la extracción, y la combinación es un raspador que sobrevive a los rediseños.

¿Listo para alimentar a su extractor con páginas reales?

La capa de obtención en esta guía es un POST por página en la API de Raspado Universal — los planes y volúmenes de solicitud están en la página de precios, y la documentación para desarrolladores cubre cada parámetro que unlocker.webunlocker acepta. Crea una clave en el plan gratuito en app.scrapeless.com y vuelve a ejecutar los dos scripts de obtención tú mismo.

Preguntas Frecuentes

P: ¿Puede ChatGPT raspar sitios web directamente?

No. El modelo no puede emitir solicitudes HTTP, ejecutar JavaScript o pasar controles anti-bot — extrae de texto que algo más obtuvo. Los productos de chat para consumidores a veces envuelven el modelo con una herramienta de navegación, pero esa herramienta es de pequeña escala y está bloqueada por muchos sitios, razón por la cual las configuraciones de producción emparejan el modelo con una capa de obtención dedicada.

P: ¿Es legal raspar con ChatGPT?

La capa de extracción no cambia las reglas de la capa de recolección. Raspe solo páginas públicas, respete los términos del sitio y las directrices de robots definidas por el Protocolo de Exclusión de Robots, mantenga los volúmenes limitados y trate cualquier dato personal bajo las leyes de privacidad que le corresponden — las mismas obligaciones que para cualquier raspador, más los términos de uso de su proveedor de modelo.

P: ¿Cuándo es un raspador de selectores tradicional la mejor opción?

En alto volumen en diseños estables. Una llamada a LLM cuesta tokens en cada página; un script de selección no cuesta nada después de ser escrito. La división práctica: use el modelo donde los diseños varían o cambian a menudo, y código de selección generado y luego revisado donde un diseño se repite miles de veces.

P: ¿Cómo es esto diferente de un "raspador de ChatGPT"?

Dirección. Esta guía dirige el modelo hacia la web — ChatGPT es el analizador. Un raspador de ChatGPT dirige un raspador hacia ChatGPT — captura las respuestas del asistente, citas y resultados de productos como datos estructurados. Scrapeless envía eso como un actor; la guía de la API de Raspador de ChatGPT vinculada en la introducción lo cubre.

P: ¿Qué modelo de OpenAI debo usar para la extracción?

Comience con un modelo pequeño y actual y solo suba si la calidad de extracción lo exige. Las salidas estructuradas constriñen la forma de respuesta independientemente del tamaño del modelo, por lo que los niveles más pequeños manejan esquemas bien definidos sobre entradas limpias — gaste los ahorros en obtener más páginas en su lugar.