> ## Documentation Index
> Fetch the complete documentation index at: https://docs.firecrawl.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Agent

> Recopila datos dondequiera que se encuentren en la web.

**Elegir la herramienta adecuada.** Agent es la opción correcta cuando **no conoces las URL** o necesitas navegación autónoma por la web.

* Para **una única URL conocida**, el [modo JSON en `/scrape`](/es/features/llm-extract) es más económico y sincrónico.
* Comparación completa: [Cómo elegir el extractor de datos](/es/developer-guides/usage-guides/choosing-the-data-extractor).

Firecrawl `/agent` es una API mágica que busca, navega y recopila datos desde la gama más amplia de sitios web, encontrando datos en lugares de difícil acceso y descubriéndolos de formas que ninguna otra API puede. Consigue en pocos minutos lo que a una persona le llevaría muchas horas: recopilación de datos de extremo a extremo, sin necesidad de scripts ni trabajo manual.
Tanto si necesitas un solo dato como conjuntos de datos completos a escala, Firecrawl `/agent` trabaja para obtener tus datos.

**Piensa en `/agent` como una investigación profunda de datos, ¡estén donde estén!**

<Info>
  **Research Preview**: Agent está en acceso anticipado. Es de esperar que tenga algunos detalles por pulir. Mejorará significativamente con el tiempo. [Comparte tus comentarios →](mailto:product@firecrawl.com)
</Info>

Agent se basa en todo lo bueno de `/extract` y lo lleva más allá:

* **No se requieren URL**: Describe lo que necesitas mediante el parámetro `prompt`. Las URL son opcionales
* **Búsqueda profunda en la web**: Busca y navega de forma autónoma, explorando en profundidad los sitios para encontrar tus datos
* **Fiable y preciso**: Funciona con una amplia variedad de consultas y casos de uso
* **Más rápido**: Procesa múltiples fuentes en paralelo para obtener resultados más rápidos

<Card title="Pruébalo en el Playground" icon="play" href="https://www.firecrawl.dev/agent">
  Prueba el agente en el Playground interactivo, sin necesidad de programar.
</Card>

<div id="using-agent">
  ## Uso de `/agent`
</div>

El único parámetro obligatorio es `prompt`. Describe simplemente qué datos quieres extraer. Para obtener salida estructurada, proporciona un esquema JSON. Los SDK son compatibles con Pydantic (Python) y Zod (Node) para definiciones de esquemas con tipado seguro:

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl
  from pydantic import BaseModel, Field
  from typing import List, Optional

  app = Firecrawl(api_key="fc-YOUR_API_KEY")

  class Founder(BaseModel):
      name: str = Field(description="Full name of the founder")
      role: Optional[str] = Field(None, description="Role or position")
      background: Optional[str] = Field(None, description="Professional background")

  class FoundersSchema(BaseModel):
      founders: List[Founder] = Field(description="Lista de fundadores")

  result = app.agent(
      prompt="Find the founders of Firecrawl",
      schema=FoundersSchema,
      model="spark-1-mini",
      max_credits=100
  )

  print(result.data)
  ```

  ```js Node theme={null}
  import { Firecrawl } from 'firecrawl';
  import { z } from 'zod';

  const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" });

  const result = await firecrawl.agent({
    prompt: "Find the founders of Firecrawl",
    schema: z.object({
      founders: z.array(z.object({
        name: z.string().describe("Full name of the founder"),
        role: z.string().describe("Role or position").optional(),
        background: z.string().describe("Professional background").optional()
      })).describe("List of founders")
    }),
    model: "spark-1-mini",
    maxCredits: 100
  });

  console.log(result.data);
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.firecrawl.dev/v2/agent" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "prompt": "Find the founders of Firecrawl",
      "model": "spark-1-mini",
      "maxCredits": 100,
      "schema": {
        "type": "object",
        "properties": {
          "founders": {
            "type": "array",
            "description": "List of founders",
            "items": {
              "type": "object",
              "properties": {
                "name": { "type": "string", "description": "Full name" },
                "role": { "type": "string", "description": "Role or position" },
                "background": { "type": "string", "description": "Professional background" }
              },
              "required": ["name"]
            }
          }
        },
        "required": ["founders"]
      }
    }'
  ```
</CodeGroup>

<div id="response">
  ### Respuesta
</div>

```json JSON theme={null}
{
  "success": true,
  "status": "completed",
  "data": {
    "founders": [
      {
        "name": "Eric Ciarla",
        "role": "Co-founder",
        "background": "Previously at Mendable"
      },
      {
        "name": "Nicolas Camara",
        "role": "Co-founder",
        "background": "Previously at Mendable"
      },
      {
        "name": "Caleb Peffer",
        "role": "Co-founder",
        "background": "Previously at Mendable"
      }
    ]
  },
  "expiresAt": "2024-12-15T00:00:00.000Z",
  "creditsUsed": 15
}
```

<div id="providing-urls-optional">
  ## Proporcionar URLs (opcional)
</div>

Puedes proporcionar URLs opcionalmente para centrar al agente en páginas específicas:

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

  app = Firecrawl(api_key="fc-YOUR_API_KEY")

  result = app.agent(
      urls=["https://docs.firecrawl.dev", "https://firecrawl.dev/pricing"],
      prompt="Compara las características y la información de precios de estas páginas"
  )

  print(result.data)
  ```

  ```js Node theme={null}
  import { Firecrawl } from 'firecrawl';

  const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" });

  const result = await firecrawl.agent({
    urls: ["https://docs.firecrawl.dev", "https://firecrawl.dev/pricing"],
    prompt: "Compare the features and pricing information from these pages"
  });

  console.log(result.data);
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.firecrawl.dev/v2/agent" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "urls": [
        "https://docs.firecrawl.dev",
        "https://firecrawl.dev/pricing"
      ],
      "prompt": "Compare the features and pricing information from these pages"
    }'
  ```
</CodeGroup>

<div id="job-status-and-completion">
  ## Estado y finalización de trabajos
</div>

Los trabajos de agente se ejecutan de forma asíncrona. Cuando envíes un trabajo, recibirás un ID de trabajo que podrás usar para comprobar su estado:

* **Método predeterminado**: `agent()` espera y devuelve los resultados finales
* **Iniciar y luego consultar**: Usa `start_agent` (Python) o `startAgent` (Node) para obtener un ID de trabajo de inmediato y luego consulta su estado con `get_agent_status` / `getAgentStatus`

<Note>Los resultados de los trabajos estarán disponibles a través de la API durante 24 horas después de su finalización. Pasado este período, aún puedes ver el historial y los resultados de tu agente en los [registros de actividad](https://www.firecrawl.dev/app/logs).</Note>

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

  app = Firecrawl(api_key="fc-YOUR_API_KEY")

  # Iniciar una tarea del agente
  agent_job = app.start_agent(
      prompt="Find the founders of Firecrawl"
  )

  # Check the status
  status = app.get_agent_status(agent_job.id)

  print(status)
  # Example output:
  # status='completed'
  # success=True
  # data={ ... }
  # expires_at=datetime.datetime(...)
  # credits_used=15
  ```

  ```js Node theme={null}
  import { Firecrawl } from 'firecrawl';

  const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" });

  // Inicia una tarea de agente
  const started = await firecrawl.startAgent({
    prompt: "Find the founders of Firecrawl"
  });

  // Verifica el estado
  if (started.id) {
    const status = await firecrawl.getAgentStatus(started.id);
    console.log(status.status, status.data);
  }
  ```

  ```bash cURL theme={null}
  curl -X GET "https://api.firecrawl.dev/v2/agent/<jobId>" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY"
  ```
</CodeGroup>

<div id="possible-states">
  ### Posibles estados
</div>

| Estado       | Descripción                                       |
| ------------ | ------------------------------------------------- |
| `processing` | El agente todavía está trabajando en tu solicitud |
| `completed`  | La extracción finalizó correctamente              |
| `failed`     | Se produjo un error durante la extracción         |
| `cancelled`  | El trabajo fue cancelado por el usuario           |

<Note>
  **La cancelación es cooperativa.** Cuando llamas al endpoint de cancelación, la solicitud se registra de inmediato, pero cualquier paso que ya esté en curso (un paso de razonamiento del LLM, una llamada a una herramienta o una acción del navegador) se ejecuta hasta completarse correctamente antes de que el trabajo pase a `cancelled`. Los créditos pueden seguir acumulándose durante ese breve intervalo, por lo que el valor final de `creditsUsed` puede ser mayor que el valor informado en el momento en que hiciste clic en cancelar.
</Note>

<div id="pending-example">
  #### Ejemplo en estado pendiente
</div>

```json JSON theme={null}
{
  "success": true,
  "status": "processing",
  "expiresAt": "2024-12-15T00:00:00.000Z"
}
```

<div id="completed-example">
  #### Ejemplo completado
</div>

```json JSON theme={null}
{
  "success": true,
  "status": "completed",
  "data": {
    "founders": [
      {
        "name": "Eric Ciarla",
        "role": "Co-founder"
      },
      {
        "name": "Nicolas Camara",
        "role": "Co-founder"
      },
      {
        "name": "Caleb Peffer",
        "role": "Co-founder"
      }
    ]
  },
  "expiresAt": "2024-12-15T00:00:00.000Z",
  "creditsUsed": 15
}
```

<div id="share-agent-runs">
  ## Compartir ejecuciones del agente
</div>

Puedes compartir ejecuciones del agente directamente desde el Agent Playground. Los enlaces compartidos son públicos: cualquier persona que tenga el enlace puede ver la salida y la actividad de la ejecución, y puedes revocar el acceso en cualquier momento para desactivar el enlace. Los motores de búsqueda no indexan las páginas compartidas.

<div id="model-selection">
  ## Selección de modelo
</div>

Firecrawl Agent ofrece dos modelos. **Spark 1 Mini es un 60% más barato** y es el modelo predeterminado — perfecto para la mayoría de los casos de uso. Pásate a Spark 1 Pro cuando necesites la máxima precisión en tareas complejas.

| Modelo         | Coste              | Precisión | Ideal para                                 |
| -------------- | ------------------ | --------- | ------------------------------------------ |
| `spark-1-mini` | **60% más barato** | Estándar  | La mayoría de las tareas (predeterminado)  |
| `spark-1-pro`  | Estándar           | Mayor     | Investigación compleja, extracción crítica |

<Tip>
  **Empieza con Spark 1 Mini** (predeterminado) — gestiona bien la mayoría de las tareas de extracción con un coste un 60% menor. Cambia a Pro solo para investigación compleja en múltiples dominios o cuando la precisión sea crítica.
</Tip>

<div id="spark-1-mini-default">
  ### Spark 1 Mini (predeterminado)
</div>

`spark-1-mini` es nuestro modelo eficiente, ideal para tareas sencillas de extracción de datos.

**Usa Mini cuando:**

* Necesites extraer datos simples (información de contacto, precios, etc.)
* Trabajes con sitios web bien estructurados
* La eficiencia de costos sea una prioridad
* Debas ejecutar trabajos de extracción de alto volumen

<div id="spark-1-pro">
  ### Spark 1 Pro
</div>

`spark-1-pro` es nuestro modelo insignia, diseñado para lograr la máxima precisión en tareas de extracción complejas.

**Usa Pro cuando:**

* Realices análisis de la competencia complejos
* Extraigas datos que requieran razonamiento profundo
* La precisión sea crítica para tu caso de uso
* Trates con datos ambiguos o difíciles de encontrar

<div id="specifying-a-model">
  ### Especificar un modelo
</div>

Pasa el parámetro `model` para seleccionar el modelo que quieres usar:

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

  app = Firecrawl(api_key="fc-YOUR_API_KEY")

  # Usando Spark 1 Mini (predeterminado - puede omitirse)
  result = app.agent(
      prompt="Find the pricing of Firecrawl",
      model="spark-1-mini"
  )

  # Using Spark 1 Pro for complex tasks
  result = app.agent(
      prompt="Compare all enterprise features and pricing across Firecrawl, Apify, and ScrapingBee",
      model="spark-1-pro"
  )

  print(result.data)
  ```

  ```js Node theme={null}
  import { Firecrawl } from 'firecrawl';

  const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" });

  // Usando Spark 1 Mini (predeterminado - puede omitirse)
  const result = await firecrawl.agent({
    prompt: "Find the pricing of Firecrawl",
    model: "spark-1-mini"
  });

  // Usando Spark 1 Pro para tareas complejas
  const resultPro = await firecrawl.agent({
    prompt: "Compare all enterprise features and pricing across Firecrawl, Apify, and ScrapingBee",
    model: "spark-1-pro"
  });

  console.log(result.data);
  ```

  ```bash cURL theme={null}
  # Using Spark 1 Mini (default)
  curl -X POST "https://api.firecrawl.dev/v2/agent" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "prompt": "Find the pricing of Firecrawl",
      "model": "spark-1-mini"
    }'

  # Using Spark 1 Pro for complex tasks
  curl -X POST "https://api.firecrawl.dev/v2/agent" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "prompt": "Compara todas las características empresariales y precios entre Firecrawl, Apify y ScrapingBee",
      "model": "spark-1-pro"
    }'
  ```
</CodeGroup>

<div id="parameters">
  ## Parámetros
</div>

| Parámetro    | Tipo   | Obligatorio | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------ | ------ | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `prompt`     | string | **Sí**      | Descripción en lenguaje natural de los datos que deseas extraer (máx. 10.000 caracteres)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `model`      | string | No          | Modelo a utilizar: `spark-1-mini` (predeterminado) o `spark-1-pro`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `urls`       | array  | No          | Lista opcional de URLs en las que centrar la extracción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `schema`     | object | No          | Esquema JSON opcional para una salida estructurada                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `maxCredits` | number | No          | Número máximo de créditos que se pueden usar en esta tarea del agente. De forma predeterminada es **2,500** si no se especifica. El panel de control admite valores de hasta **2,500**; para límites superiores, configura `maxCredits` mediante la API (los valores por encima de 2,500 siempre se tratan como solicitudes de pago). Si se alcanza el límite, el trabajo falla y **no se devuelve ningún dato**. Las ejecuciones fallidas no se facturan: los créditos usados para el razonamiento de IA nunca se cobran en caso de fallo, cualquier crédito usado para llamadas a herramientas durante la ejecución (`scraping`, `search`, `mapping`, etc.) se reembolsa, y la respuesta informa `creditsUsed: 0`. |

<div id="agent-vs-extract-whats-improved">
  ## Agent vs Extract: Qué ha mejorado
</div>

| Característica                | Agent (nuevo) | Extract  |
| ----------------------------- | ------------- | -------- |
| URLs necesarias               | No            | Sí       |
| Velocidad                     | Más rápida    | Estándar |
| Costo                         | Más bajo      | Estándar |
| Fiabilidad                    | Más alta      | Estándar |
| Flexibilidad de las consultas | Alta          | Moderada |

<div id="example-use-cases">
  ## Ejemplos de casos de uso
</div>

* **Investigación**: "Encuentra las 5 principales startups de IA y sus montos de financiación"
* **Análisis de la competencia**: "Compara los planes de precios entre Slack y Microsoft Teams"
* **Recopilación de datos**: "Extrae información de contacto de sitios web de empresas"
* **Resumen de contenido**: "Resume las últimas entradas de blog sobre web scraping"

<div id="csv-upload-in-agent-playground">
  ## Carga de archivos CSV en Agent Playground
</div>

El [Agent Playground](https://www.firecrawl.dev/app/agent) admite la carga de archivos CSV para el procesamiento por lotes. Tu CSV puede contener una o más columnas de datos de entrada. Por ejemplo, una sola columna con nombres de empresas, o varias columnas como nombre de la empresa, producto y URL del sitio web. Cada fila representa un elemento que el agente debe procesar.

Sube tu CSV y luego agrega columnas de salida con el botón "+" en el encabezado de la cuadrícula. Cada columna tiene su propio prompt: haz clic en el encabezado de una columna para describir qué debe encontrar el agente para ese campo (p. ej., "Nombre del CEO o fundador", "Financiación total obtenida"). Pulsa Run y el agente procesa cada fila en paralelo y completa los resultados.

<div id="troubleshooting-with-ask">
  ## Solución de problemas con Ask
</div>

Si los trabajos de tu agente fallan o devuelven resultados inesperados, usa la [API de Ask](/es/features/ask) para depuración agentic. Describe el problema y obtén una respuesta verificada con parámetros de solución que puedes aplicar directamente:

```bash theme={null}
curl -X POST https://api.firecrawl.dev/v2/support/ask \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "question": "my agent returned incomplete results"
  }'
```

Consulta la [documentación de Ask](/es/features/ask) para conocer todos los detalles y ejemplos de integración.

<div id="api-reference">
  ## Referencia de la API
</div>

Consulta la [Agent API Reference](/es/api-reference/endpoint/agent) para más detalles.

¿Tienes comentarios o necesitas ayuda? Escríbenos a [help@firecrawl.com](mailto:help@firecrawl.com).

<div id="pricing">
  ## Precios
</div>

Firecrawl Agent usa **facturación dinámica** que se ajusta a la complejidad de tu solicitud de extracción de datos. Pagas según el trabajo real que realiza Agent, lo que garantiza un precio justo tanto si estás extrayendo datos simples como información estructurada compleja de múltiples fuentes.

<div id="how-agent-pricing-works">
  ### Cómo funcionan los precios de Agent
</div>

Los precios de Agent son **dinámicos y basados en créditos** durante la Research Preview:

* **Extracciones simples** (como obtener información de contacto de una sola página) suelen usar menos créditos y cuestan menos
* **Tareas de investigación complejas** (como análisis de la competencia en múltiples dominios) usan más créditos, pero reflejan el esfuerzo total involucrado
* **Uso transparente** te muestra exactamente cuántos créditos consumió cada solicitud
* **Conversión de créditos** convierte automáticamente el uso de créditos del agente en créditos para una facturación sencilla

<Info>
  El uso de créditos varía según la complejidad de tu prompt, la cantidad de datos procesados y la estructura de la salida solicitada. Como guía aproximada, la mayoría de las ejecuciones de agentes consumen **unos pocos cientos de créditos**, aunque las tareas simples de una sola página pueden usar menos y las investigaciones complejas en múltiples dominios pueden usar más.
</Info>

<div id="parallel-agents-pricing">
  ### Precios de agentes en paralelo
</div>

Si estás ejecutando varios agentes en paralelo con Spark-1 Fast, el precio es mucho más predecible: 10 créditos por celda.

<div id="getting-started">
  ### Primeros pasos
</div>

**Todos los usuarios** reciben **5 ejecuciones gratuitas al día**, que pueden utilizarse tanto desde el playground como desde la API, para explorar las capacidades de Agent sin costo.

El uso adicional se cobra en función del consumo de créditos y se convierte en créditos.

<div id="managing-costs">
  ### Gestión de costos
</div>

Agent puede resultar costoso, pero hay algunas formas de reducir el costo:

* **Empieza con ejecuciones gratuitas**: Usa tus 5 solicitudes gratuitas diarias para entender los precios
* **Configura el parámetro `maxCredits`**: Limita tu gasto estableciendo un número máximo de créditos que estás dispuesto a usar. El panel de control limita esto a 2,500 créditos; para establecer un límite más alto, usa el parámetro `maxCredits` directamente a través de la API (nota: los valores por encima de 2,500 siempre se facturan como solicitudes pagadas)
* **Optimiza los prompts**: Los prompts más específicos suelen consumir menos créditos
* **Divide las tareas grandes en ejecuciones más pequeñas**: Una sola ejecución de Agent tiene un límite de salida basado en la capacidad de generación del modelo subyacente (\~150-200 filas de datos estructurados). Para trabajos de extracción grandes, divide por categoría, región o lote de URL (3-5 URL por ejecución) y combina los resultados. Esto también mantiene cada ejecución muy por debajo del límite de `maxCredits`.
* **Supervisa tu uso**: Haz seguimiento de tu consumo desde el panel de control
* **Define expectativas**: Las investigaciones complejas en múltiples dominios consumirán más créditos que las extracciones simples de una sola página

Prueba Agent ahora en [firecrawl.dev/app/agent](https://www.firecrawl.dev/app/agent) para ver cómo escala el consumo de créditos según tus casos de uso específicos.

<Note>
  Los precios están sujetos a cambios a medida que pasamos de la Research Preview a la disponibilidad general. Los usuarios actuales recibirán aviso previo de cualquier actualización de precios.
</Note>

> ¿Eres un Agent de IA que necesita una API key de Firecrawl? Consulta [firecrawl.dev/agent-onboarding/SKILL.md](https://www.firecrawl.dev/agent-onboarding/SKILL.md) para obtener instrucciones de incorporación automatizada.