Agente de scraping: qué es y cómo construir uno

Un scraper tradicional es un conjunto de instrucciones: descarga esta URL, lee .product-price, devuelve el texto. Un agente de scraping es un objetivo: encuentra el precio actual, tenga el aspecto que tenga la página hoy.

Esa diferencia suena académica hasta que el sitio lanza un rediseño. El que sigue instrucciones devuelve null y tu pipeline se queda en silencio. El que persigue un objetivo mira la página, se da cuenta de que el precio se ha movido a un modal detrás de un botón "Ver precios", hace clic y devuelve el número.

También suena a barra libre, y no lo es. Los agentes de scraping son más lentos, más caros por página y de vez en cuando se equivocan con total confianza, algo que un selector roto nunca hace. Esta guía cubre qué es realmente un agente de scraping (o agent scraper, como se le conoce en inglés), las tres formas de construir uno, código funcional para dos de ellas y -- la parte que casi todos los artículos se saltan -- las condiciones concretas bajo las que no deberías usar uno en absoluto.

Tabla de contenidos

• ¿Qué es un agente de scraping?
• ¿Cómo funciona un agente de scraping?
• Agente de scraping vs scraper tradicional
• Las tres formas de construir un agente de scraping
• Constrúyelo con una sola llamada
• Construye tu propio bucle de agente
• ¿Por qué fallan los agentes de scraping en producción?
• ¿Cuánto cuesta un agente de scraping?
• ¿Cuándo no deberías usar un agente de scraping?
• Cinco salvaguardas antes de lanzarlo
• Preguntas frecuentes

¿Qué es un agente de scraping?

Un agente de scraping es un scraper web gobernado por un bucle de razonamiento LLM en lugar de por un script fijo. Le das un objetivo en lenguaje natural -- "encuentra todos los planes de precios de este sitio y qué incluye cada uno" -- y él decide qué páginas descargar, cuándo escalar a un navegador, cuándo tiene información suficiente y cómo dar forma a la respuesta. Sin selectores CSS, sin XPath, sin mantenimiento por sitio.

Tres propiedades lo separan de todo lo anterior:

1. Planifica. La secuencia de peticiones se elige en tiempo de ejecución a partir del objetivo, no se codifica de antemano.
2. Se adapta. Un 403, un resultado vacío o un diseño inesperado son una entrada para la siguiente decisión, no un error fatal.
3. Termina por una condición, no por un contador. Se detiene cuando el objetivo está satisfecho -- que es exactamente por lo que debes imponerle límites duros desde fuera.

El término se usa a la ligera, así que conviene precisar qué no es un agente de scraping. Un scraper que llama una vez a un LLM para limpiar el HTML extraído hace scraping asistido por IA: el flujo de control sigue siendo tu script. Un script de automatización de navegador con un LLM eligiendo selectores en tiempo de desarrollo hace scraping generado por IA: el LLM escribió código que luego se ejecuta de forma determinista. Solo cuando el modelo está dentro del bucle, eligiendo la siguiente acción en cada turno, tienes un agente de scraping.

¿Cómo funciona un agente de scraping?

Todo agente de scraping, sea cual sea el framework, ejecuta el mismo bucle de seis etapas:

1. Objetivo. Una meta en lenguaje natural, más URLs semilla opcionales.
2. Plan. El modelo decide la primera acción -- normalmente una búsqueda o una descarga.
3. Actuar. Invoca una herramienta: descargar una URL, lanzar una búsqueda, manejar un navegador, escalar por encima de un muro anti-bot.
4. Observar. La herramienta devuelve contenido, idealmente como markdown limpio y no como HTML crudo, porque cada byte acaba en la ventana de contexto.
5. Evaluar. ¿Está cumplido el objetivo? Si no, ¿qué falta y qué acción cierra el hueco?
6. Emitir. Devolver prosa o, mejor, JSON validado contra un esquema que tú hayas facilitado.

Las etapas 2 a 5 se repiten. Y ese bucle no tiene límite por defecto -- que es lo más importante que hay que entender sobre ejecutar uno en producción.

El modo de fallo no es que el agente se atasque. Es que el agente sigue siendo productivo: no para de encontrar una página más que parece relevante, y se come tu presupuesto haciendo un trabajo genuinamente razonable que tú no pediste. Por eso los límites duros van en el orquestador, nunca en el prompt. La herramienta agent de CrawlForge impone tres de ellos en la capa de infraestructura, donde el modelo no puede negociarlos:

Pedirle amablemente a un modelo que "solo revise unas pocas páginas" no es un límite. Un número que el runtime hace cumplir sí lo es.

Agente de scraping vs scraper tradicional

Ninguno de los dos enfoques domina. Fallan en direcciones opuestas, y eso es lo que hace manejable la elección.

Esa última fila de modos de fallo es la que hay que interiorizar. Un selector roto se anuncia solo: tu recuento de filas cae a cero y salta la monitorización. Un campo inventado no. Llega con el tipo correcto, con formato plausible, y equivocado. Cualquier agente de scraping que alimente una decisión importante necesita validación aguas abajo, y a eso volvemos en la sección de salvaguardas.

Las tres formas de construir un agente de scraping

La mayoría de los equipos debería empezar por la primera, graduarse a la segunda cuando necesite un flujo de control propio, y recurrir a la tercera solo cuando los datos estén realmente detrás de una interacción a la que una descarga simple no llega. La tercera es además, con diferencia, la más lenta y la más cara: un paso de navegador cuesta segundos donde una descarga cuesta milisegundos.

La opción intermedia es donde el Model Context Protocol se gana el sueldo. Como los servidores MCP exponen esquemas de herramientas tipados que el agente lee en tiempo de ejecución, tu bucle no necesita un wrapper escrito a mano por endpoint: el agente descubre que stealth_mode existe y qué parámetros acepta. Desglosamos esa arquitectura en MCP vs REST para scraping, y repasamos el panorama en las mejores herramientas de web scraping para agentes de IA.

Constrúyelo con una sola llamada

El agente de scraping más rápido es el que no escribes. CrawlForge incluye agent como una de sus 27 herramientas MCP: planifica sus propias búsquedas, descarga y filtra páginas, y sintetiza una respuesta -- sin necesidad de URLs y con los límites duros de arriba ya impuestos.

Conectado a Claude Code, Claude Desktop o Cursor, la versión en lenguaje natural es toda la interfaz:

Find the current pricing tiers for Vercel, Netlify, and Railway,
and tell me what each tier includes.

Por debajo, eso se resuelve en una única llamada a la herramienta:

{
  "name": "agent",
  "arguments": {
    "prompt": "Find the current pricing tiers for Vercel, Netlify and Railway, and what each tier includes.",
    "maxUrls": 12,
    "maxSteps": 6
  }
}

La prosa está bien si es una persona quien va a leer la respuesta. Para un pipeline, pasa un schema y el agente devolverá JSON validado en su lugar -- la diferencia entre un párrafo que tienes que parsear y un registro que puedes insertar:

{
  "name": "agent",
  "arguments": {
    "prompt": "Extract every pricing tier for the three vendors below.",
    "urls": [
      "https://vercel.com/pricing",
      "https://www.netlify.com/pricing/",
      "https://railway.com/pricing"
    ],
    "maxUrls": 12,
    "schema": {
      "type": "object",
      "properties": {
        "tiers": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "vendor": { "type": "string" },
              "tier": { "type": "string" },
              "monthlyUsd": { "type": "number" },
              "includes": { "type": "array", "items": { "type": "string" } }
            },
            "required": ["vendor", "tier"]
          }
        }
      }
    }
  }
}

Dos detalles que conviene conocer. Las urls semilla acotan el espacio de búsqueda cuando ya sabes dónde viven los datos -- el agente sigue decidiendo cómo leer esas páginas, pero deja de adivinar por dónde empezar. Y model: "pro" cambia el bucle por defecto por una investigación multifuente completa; cuesta más tiempo y más credits, así que resérvalo para cuando la amplitud importe más que la latencia.

Una llamada a agent son 8 credits, planos, tanto si lee tres páginas como si lee veinte.

Construye tu propio bucle de agente

Cuando necesitas un flujo de control propio -- tu política de reintentos, tu condición de parada, resultados escritos en tu propio almacén -- escribes el bucle y tratas a CrawlForge como la capa de herramientas. El patrón que importa aquí es la escalera de escalado: empieza barato y escala solo cuando falle.

const BASE = 'https://www.crawlforge.dev/api/v1/tools';

type Rung = { tool: string; credits: number; body: (url: string) => object };

// Cheapest first. Each rung costs more and handles more hostile pages.
const LADDER: Rung[] = [
  { tool: 'scrape', credits: 2, body: (url) => ({ url, formats: ['markdown'] }) },
  {
    tool: 'scrape_with_actions',
    credits: 5,
    body: (url) => ({ url, actions: [{ type: 'scroll', delay: 1500 }] }),
  },
  {
    tool: 'stealth_mode',
    credits: 5,
    body: (url) => ({ url, stealth_config: { anti_detection_level: 'advanced' } }),
  },
];

async function call(tool: string, body: object) {
  const res = await fetch(`${BASE}/${tool}`, {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.CRAWLFORGE_API_KEY ?? '',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(body),
  });
  return res.json();
}

async function fetchWithEscalation(url: string) {
  let spent = 0;

  for (const rung of LADDER) {
    const result = await call(rung.tool, rung.body(url));
    spent += rung.credits;

    // A 200 with 200 characters of "enable JavaScript" is still a failure.
    const markdown = result?.data?.markdown ?? '';
    if (result.success && markdown.length > 500) {
      return { markdown, spent, via: rung.tool };
    }
  }

  return { markdown: null, spent, via: null };
}

La comprobación markdown.length > 500 es la parte que la gente se deja, y es donde la mayoría de los agentes de scraping caseros se rompen en silencio. Las páginas anti-bot devuelven HTTP 200. Un intersticial de desafío es una respuesta exitosa que no contiene datos, así que res.ok no te dice nada: tienes que inspeccionar lo que ha llegado antes de decidir que el peldaño ha funcionado. (Para el panorama completo de aquello a lo que se enfrenta el escalado, consulta cómo esquivar la detección anti-bot con el modo sigiloso.)

Con la capa de descarga resuelta, el bucle del agente en sí es pequeño: dale el objetivo al modelo, deja que elija URLs, pasa cada una por fetchWithEscalation y para cuando el esquema esté satisfecho o se agote tu presupuesto de pasos. La escalera de escalado es lo que lo hace asequible: la mayoría de las páginas se resuelven en el primer peldaño por 2 credits, y solo pagas 5 por las que se resisten.

¿Por qué fallan los agentes de scraping en producción?

Cuatro modos de fallo, más o menos en el orden en que suelen morder.

La inteligencia no derrota al fingerprinting. Este es el malentendido que más dinero cuesta a los equipos. La protección anti-bot evalúa huellas TLS, la consistencia de las API del navegador, los tiempos de las peticiones y la entropía de las cabeceras, y un LLM no influye en ninguna de esas señales. Un agente conduciendo un Chromium headless de serie se detecta con la misma tasa que cualquier otro Chromium headless, a veces más alta, porque los patrones de navegación de un agente (directo al elemento objetivo, sin scroll, con tiempos irregulares) parecen menos humanos que los de un script. ScrapeWise, que vende infraestructura de scraping gestionada, reporta tasas de bloqueo del 61-74% para agentes sin asistencia frente a objetivos de e-commerce protegidos por Cloudflare y Akamai en sus propias pruebas de abril de 2026. Toma los benchmarks de un proveedor como orientativos más que como definitivos, pero el mecanismo se sostiene: pagas costes de inferencia por trabajos que mueren en el WAF, antes de que la extracción llegue siquiera a empezar.

La economía se invierte a escala. El scraping con agentes es barato para cientos de páginas y ruinoso para millones, porque el coste de inferencia del LLM es por página y no se amortiza. Un pipeline determinista construido una vez y mantenido de vez en cuando le gana a un bucle de razonamiento por un orden de magnitud en volumen. El punto de cruce está más abajo de lo que la mayoría de los equipos espera -- mira la tabla de costes de más abajo.

Respuestas plausibles pero falsas. Un agente que no encuentra un campo es perfectamente capaz de inferirlo del texto de alrededor. La salida es válida según el esquema, con el tipo correcto, y falsa. Los scrapers basados en selectores no pueden cometer este error; simplemente no devuelven nada.

La latencia descarta el trabajo de alta frecuencia. La inferencia añade segundos por página. Cualquier cosa que necesite refrescarse en menos de un minuto sobre muchas URLs -- vigilancia de precios en vivo, disponibilidad de stock -- pertenece a un pipeline determinista con un agente lo más lejos posible del camino crítico.

Hay una quinta consideración que no es un modo de fallo sino un cambio del terreno de juego: cada vez más sitios distinguen el tráfico de agentes del tráfico de crawlers y lo tratan de forma distinta. El informe 2026 State of AI Traffic de HUMAN Security sitúa el crecimiento interanual del tráfico de agentes de IA en un 7.851%, y señala que los agentes interactúan con los sitios allí donde los crawlers solo leen. Espera que las políticas de acceso bajo las que haces scraping sigan moviéndose. Nuestra guía sobre si el web scraping es legal en 2026 cubre la parte de cumplimiento.

¿Cuánto cuesta un agente de scraping?

Esta es la aritmética honesta, usando los costes planos por llamada en credits de CrawlForge. Las cifras en dólares asumen el plan Hobby a 19 USD por 5.000 credits (0,0038 USD/credit); en Professional (99 USD por 50.000) cada cifra baja alrededor de un 48%.

Lee las dos últimas filas juntas, porque contienen la lección entera. Salida idéntica; una décima parte del coste. Una vez que sabes qué URLs quieres, un agente es la herramienta equivocada: la extracción por lotes es 10× más barata para esas mismas 100 páginas.

De ahí sale una regla limpia: usa el agente para averiguar qué descargar, y las herramientas por lotes para descargarlo. El descubrimiento es donde el razonamiento se paga solo. El volumen es donde te arruina. Una ejecución que use agent para identificar 100 URLs relevantes y luego batch_scrape para traerlas cuesta 28 credits -- unos once céntimos -- mientras que la versión del mismo trabajo hecha solo con agente cuesta 40 y tarda mucho más.

¿Cuándo no deberías usar un agente de scraping?

Sáltate el agente por completo cuando se cumpla cualquiera de estas condiciones:

• La estructura del sitio es estable y conocida. Un selector que escribes una vez y tocas dos veces al año es más barato y más rápido que razonar sobre el mismo diseño en cada ejecución.
• Necesitas más de unos pocos miles de páginas al día. El coste de inferencia y la latencia escalan linealmente y ninguno de los dos se amortiza.
• El determinismo es un requisito. Informes financieros, cumplimiento normativo, cualquier cosa auditada. "Casi siempre la misma respuesta" no es una propiedad aceptable.
• El intervalo de refresco es inferior a un minuto. Usa track_changes con un diff determinista en su lugar.
• La salida alimenta una decisión automatizada sin revisión humana. No es un nunca -- pero solo con la validación que se describe más abajo.

El patrón de producción más sólido no es agente-o-script. Es un agente que se ejecuta una vez para descubrir la estructura y generar una especificación de extracción determinista, y un trabajo determinista programado que la ejecuta, con el agente reinvocado solo cuando ese trabajo empieza a fallar. Pagas por razonar cuando el sitio cambia, no en cada fila.

Cinco salvaguardas antes de lanzarlo

1. Impón los presupuestos en el orquestador. Pasos, URLs y reloj de pared, todo fuera del prompt. Un límite del que el modelo puede autoconvencerse para saltárselo no es un límite.
2. Pasa siempre un esquema de salida. La salida estructurada convierte "¿ha funcionado?" en una validación que puedes automatizar. Rechaza y reintenta cuando falle el esquema, en lugar de guardar prosa.
3. Valida contra un campo conocido. Incluye en el esquema un valor que puedas verificar de forma independiente: un SKU de producto, un título de página, un símbolo de moneda. Si ese campo está mal, descarta el registro entero; el agente estaba leyendo algo distinto de lo que crees.
4. Registra cada URL que descargó el agente. Cuando una respuesta es incorrecta, la traza de descargas es la única forma de distinguir una página mala de un razonamiento malo. Sin ella, estás depurando una caja negra.
5. Cachea con generosidad. Las ejecuciones de agentes repiten trabajo entre invocaciones. Cachear por URL con un TTL corto reduce a la mitad, de forma rutinaria, el gasto en credits de una investigación iterativa.

Pruébalo tú mismo

No necesitas un framework, una granja de navegadores ni un contrato de proxies para lanzar tu primer agente de scraping. CrawlForge expone agent junto a otras 26 herramientas a través de una sola conexión MCP, con límites de seguridad duros impuestos por el runtime y credits planos por llamada para que puedas poner precio a una ejecución antes de lanzarla.

Empieza gratis con 1.000 credits -- suficiente para 125 ejecuciones de agente -- y conéctalo a Claude, a Cursor o a tu propio bucle en unos dos minutos.