# Cómo elegir el extractor de datos (/es/developer-guides/usage-guides/choosing-the-data-extractor)

<!-- agent-signals: reading_time_min: 11 · est_tokens: 5302 · updated: 2026-07-30 -->
Related: [Plantillas Full‑Stack](/es/developer-guides/examples.md), [OpenAI](/es/developer-guides/llm-sdks-and-frameworks/openai.md)

Firecrawl ofrece tres métodos para extraer datos estructurados de páginas web. Cada uno se adapta a distintos casos de uso, con diferentes niveles de automatización y control.

<div id="quick-comparison">
  ## Comparación rápida [#comparación-rápida]
</div>

| Función                   | `/agent`                                             | `/extract`                                         | `/scrape` (modo JSON)                         |
| ------------------------- | ---------------------------------------------------- | -------------------------------------------------- | --------------------------------------------- |
| **Estado**                | Activo                                               | Usa `/agent` en su lugar                           | Activo                                        |
| **URL requerida**         | No (opcional)                                        | Sí (se admiten comodines)                          | Sí (URL única)                                |
| **Alcance**               | Descubrimiento en toda la web                        | Varias páginas/dominios                            | Una sola página                               |
| **Descubrimiento de URL** | Búsqueda web autónoma                                | Rastrea desde las URL dadas                        | Ninguno                                       |
| **Procesamiento**         | Asíncrono                                            | Asíncrono                                          | Síncrono                                      |
| **Esquema requerido**     | No (prompt o esquema)                                | No (prompt o esquema)                              | No (prompt o esquema)                         |
| **Precios**               | Dinámico (5 ejecuciones gratuitas al día)            | Basado en tokens (1 crédito = 15 tokens)           | 5 créditos/página (1 base + 4 para modo JSON) |
| **Ideal para**            | Investigación, descubrimiento, recopilación compleja | Extracción multipágina (cuando ya conoces las URL) | Extracción de una sola página conocida        |

<div id="1-agent-endpoint">
  ## 1. Endpoint `/agent` [#1-endpoint-agent]
</div>

El endpoint `/agent` es la funcionalidad más avanzada de Firecrawl, el sucesor de `/extract`. Utiliza agentes de IA para buscar, navegar y recopilar datos de forma autónoma en toda la web.

<div id="key-characteristics">
  ### Características clave [#características-clave]
</div>

* **URLs opcionales**: Solo tienes que describir lo que necesitas mediante el `prompt`; las URLs son completamente opcionales
* **Navegación autónoma**: El agente busca y navega en profundidad por sitios web para encontrar tus datos
* **Búsqueda profunda en la web**: Descubre información de forma autónoma en múltiples dominios y páginas
* **Procesamiento en paralelo**: Procesa múltiples fuentes simultáneamente para obtener resultados más rápidos
* **Modelos disponibles**: `spark-1-mini` (predeterminado, 60% más económico) y `spark-1-pro` (mayor precisión)

<div id="example">
  ### Ejemplo [#ejemplo]
</div>

<CodeGroup>
  <CodeBlockTabs defaultValue="Python" groupId="curl+node+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Node">
        Node
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="cURL">
        cURL
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Python">
      ```python  
      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)
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Node">
      ```js  
      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);
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      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"]
          }
        }'
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<div id="best-use-case-autonomous-research-discovery">
  ### Caso de uso ideal: investigación y descubrimiento autónomos [#caso-de-uso-ideal-investigación-y-descubrimiento-autónomos]
</div>

**Escenario**: Necesitas encontrar información sobre startups de IA que hayan obtenido una ronda de financiación Serie A, incluyendo sus fundadores y los montos financiados.

**Por qué `/agent`**: No sabes qué sitios web contienen esta información. El agente buscará de forma autónoma en la web, navegará a fuentes relevantes (Crunchbase, sitios de noticias, páginas de empresas) y recopilará los datos estructurados por ti.

Para más información, consulta la [documentación del agente](/es/features/agent).

***

<div id="2-extract-endpoint">
  ## 2. Endpoint `/extract` [#2-endpoint-extract]
</div>

<Note>
  **Usa `/agent` en su lugar**: Recomendamos migrar a [`/agent`](/es/features/agent): es más rápido, más fiable, no requiere URL y cubre todos los casos de uso de `/extract` y más.
</Note>

El endpoint `/extract` recopila datos estructurados a partir de URL específicas o dominios completos usando extracción basada en LLM.

<div id="key-characteristics">
  ### Características clave [#características-clave-1]
</div>

* **URLs normalmente requeridas**: Proporciona al menos una URL (admite comodines como `example.com/*`)
* **Rastreo de dominio**: Puede rastrear y analizar todas las URLs descubiertas en un dominio
* **Mejora de la búsqueda web**: `enableWebSearch` opcional para seguir enlaces fuera de los dominios especificados
* **Esquema opcional**: Admite un esquema JSON estricto O prompts en lenguaje natural
* **Procesamiento asíncrono**: Devuelve un ID de tarea para comprobar el estado

<div id="the-url-limitation">
  ### La limitación de las URL [#la-limitación-de-las-url]
</div>

El desafío fundamental con `/extract` es que normalmente necesitas conocer las URL de antemano:

1. **Brecha de descubrimiento**: Para tareas como "find YC W24 companies", no sabes qué URL contienen los datos. Necesitarías un paso de búsqueda por separado antes de llamar a `/extract`.
2. **Búsqueda web poco práctica**: Aunque existe `enableWebSearch`, está limitado a comenzar desde las URL que proporcionas, lo que resulta en un flujo de trabajo poco práctico para tareas de descubrimiento.
3. **Por qué se creó `/agent`**: `/extract` es bueno para extraer desde ubicaciones conocidas, pero es menos efectivo para descubrir dónde están los datos.

<div id="example">
  ### Ejemplo [#ejemplo-1]
</div>

<CodeGroup>
  <CodeBlockTabs defaultValue="Python" groupId="curl+node+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Node">
        Node
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="cURL">
        cURL
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Python">
      ```python  
      from firecrawl import Firecrawl

      firecrawl = Firecrawl(api_key="fc-YOUR-API-KEY")

      schema = {
          "type": "object",
          "properties": {"description": {"type": "string"}},
          "required": ["description"],
      }

      res = firecrawl.extract(
          urls=["https://docs.firecrawl.dev"],
          prompt="Extrae la descripción de la página",
          schema=schema,
      )

      print(res.data["description"])
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Node">
      ```js  
      import { Firecrawl } from 'firecrawl';

      const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });

      const schema = {
        type: 'object',
        properties: {
          title: { type: 'string' }
        },
        required: ['title']
      };

      const res = await firecrawl.extract({
        urls: ['https://docs.firecrawl.dev'],
        prompt: 'Extract the page title',
        schema,
        scrapeOptions: { formats: [{ type: 'json', prompt: 'Extract', schema }] }
      });

      console.log(res.status || res.success, res.data);
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      curl -s -X POST "https://api.firecrawl.dev/v2/extract" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "urls": ["https://docs.firecrawl.dev"],
          "prompt": "Extraer el título de la página",
          "schema": {
            "type": "object",
            "properties": {"title": {"type": "string"}},
            "required": ["title"]
          },
          "scrapeOptions": {
            "formats": [{"type": "json", "prompt": "Extraer", "schema": {"type": "object"}}]
          }
        }'
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<div id="best-use-case-targeted-multi-page-extraction">
  ### Mejor caso de uso: extracción específica de múltiples páginas [#mejor-caso-de-uso-extracción-específica-de-múltiples-páginas]
</div>

**Escenario**: Tienes la URL de la documentación de tu competidor y quieres extraer todos los endpoints de su API de `docs.competitor.com/*`.

**Por qué `/extract` funcionó aquí**: Conocías el dominio exacto. Pero incluso así, hoy en día `/agent` con URLs proporcionadas normalmente ofrece mejores resultados.

Para más detalles, consulta la [documentación de Extract](/es/features/extract).

***

<div id="3-scrape-endpoint-with-json-mode">
  ## 3. Endpoint `/scrape` con modo JSON [#3-endpoint-scrape-con-modo-json]
</div>

El endpoint `/scrape` con modo JSON es el enfoque con mayor control: extrae datos estructurados de una única URL conocida usando un LLM para convertir el contenido de la página en el esquema que especifiques.

<div id="key-characteristics">
  ### Características clave [#características-clave-2]
</div>

* **Solo una URL**: Diseñado para extraer datos de una única página específica a la vez
* **URL exacta requerida**: Debes conocer la URL precisa que contiene los datos
* **Esquema opcional**: Puedes usar un esquema JSON o solo un prompt (el LLM elige la estructura)
* **Síncrono**: Devuelve los datos de inmediato (no hace falta hacer polling de jobs)
* **Formatos adicionales**: Puede combinar la extracción en JSON con markdown, HTML y capturas de pantalla en una sola solicitud

<div id="example">
  ### Ejemplo [#ejemplo-2]
</div>

<CodeGroup>
  <CodeBlockTabs defaultValue="Python" groupId="curl+node+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Node">
        Node
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="cURL">
        cURL
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Python">
      ```python  
      from firecrawl import Firecrawl
      from pydantic import BaseModel

      app = Firecrawl(
        # No se necesita API key para comenzar — agrega una para obtener límites de tasa más altos:
        # api_key="fc-YOUR-API-KEY",
      )

      class CompanyInfo(BaseModel):
          company_mission: str
          supports_sso: bool
          is_open_source: bool
          is_in_yc: bool

      result = app.scrape(
          'https://firecrawl.dev',
          formats=[{
            "type": "json",
            "schema": CompanyInfo.model_json_schema()
          }],
          only_main_content=False,
          timeout=120000
      )

      print(result)
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Node">
      ```js  
      import { Firecrawl } from "firecrawl";
      import { z } from "zod";

      const app = new Firecrawl({
        // No se necesita API key para comenzar — agrega una para límites de tasa más altos:
        // apiKey: "fc-YOUR_API_KEY",
      });

      // Definir esquema para extraer el contenido
      const schema = z.object({
        company_mission: z.string(),
        supports_sso: z.boolean(),
        is_open_source: z.boolean(),
        is_in_yc: z.boolean()
      });

      const result = await app.scrape("https://firecrawl.dev", {
        formats: [{
          type: "json",
          schema: schema
        }],
      });

      console.log(result);
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      # No se necesita API key para comenzar — añade -H "Authorization: Bearer YOUR_API_KEY" para límites de tasa más altos:
      curl -X POST https://api.firecrawl.dev/v2/scrape \
          -H 'Content-Type: application/json' \
          -d '{
            "url": "https://firecrawl.dev",
            "formats": [ {
              "type": "json",
              "schema": {
                "type": "object",
                "properties": {
                  "company_mission": {
                            "type": "string"
                  },
                  "supports_sso": {
                            "type": "boolean"
                  },
                  "is_open_source": {
                            "type": "boolean"
                  },
                  "is_in_yc": {
                            "type": "boolean"
                  }
                },
                "required": [
                  "company_mission",
                  "supports_sso",
                  "is_open_source",
                  "is_in_yc"
                ]
              }
            } ]
          }'
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<div id="best-use-case-single-page-precision-extraction">
  ### Caso de uso ideal: extracción precisa de una sola página [#caso-de-uso-ideal-extracción-precisa-de-una-sola-página]
</div>

**Escenario**: Estás creando una herramienta de monitoreo de precios y necesitas extraer el precio, la disponibilidad y los detalles del producto de una página de producto específica para la que ya tienes la URL.

**Por qué usar `/scrape` con modo JSON**: Sabes exactamente qué página contiene los datos, necesitas una extracción precisa de una sola página y quieres resultados síncronos sin la sobrecarga de gestionar tareas.

Para más detalles, consulta la [documentación del modo JSON](/es/features/llm-extract).

***

<div id="decision-guide">
  ## Guía de decisiones [#guía-de-decisiones]
</div>

**¿Conoces las URL exactas que contienen tus datos?**

* **NO** → Usa `/agent` (descubrimiento web autónomo)
* **SÍ**
  * **¿Una sola página?** → Usa `/scrape` con modo JSON
  * **¿Múltiples páginas?** → Usa `/agent` con URLs (o `/scrape` por lotes)

<div id="recommendations-by-scenario">
  ### Recomendaciones por escenario [#recomendaciones-por-escenario]
</div>

| Escenario                                                             | Endpoint recomendado                  |
| --------------------------------------------------------------------- | ------------------------------------- |
| "Encontrar todas las startups de IA y su financiación"                | `/agent`                              |
| "Extraer datos de esta página de producto específica"                 | `/scrape` (modo JSON)                 |
| "Obtener todas las publicaciones de blog de competitor.com"           | `/agent` con URL                      |
| "Monitorizar precios en múltiples URLs conocidas"                     | `/scrape` con procesamiento por lotes |
| "Investigar empresas en un sector específico"                         | `/agent`                              |
| "Extraer información de contacto de 50 páginas de empresas conocidas" | `/scrape` con procesamiento por lotes |

***

<div id="pricing">
  ## Precios [#precios]
</div>

| Endpoint              | Costo                                            | Notas                                                      |
| --------------------- | ------------------------------------------------ | ---------------------------------------------------------- |
| `/scrape` (modo JSON) | 5 créditos/página (1 base + 4 para el modo JSON) | Fijo, predecible                                           |
| `/extract`            | Basado en tokens (1 crédito = 15 tokens)         | Variable según el contenido                                |
| `/agent`              | Dinámico                                         | 5 ejecuciones gratuitas al día; varía según la complejidad |

<div id="example-find-the-founders-of-firecrawl">
  ### Ejemplo: "Encuentra a los fundadores de Firecrawl" [#ejemplo-encuentra-a-los-fundadores-de-firecrawl]
</div>

| Endpoint   | Cómo funciona                                                    | Créditos usados             |
| ---------- | ---------------------------------------------------------------- | --------------------------- |
| `/scrape`  | Encuentras la URL manualmente y luego haces scraping de 1 página | \~1 crédito                 |
| `/extract` | Proporcionas una o varias URL y extrae datos estructurados       | Variable (basado en tokens) |
| `/agent`   | Solo tienes que enviar el prompt: el agente encuentra y extrae   | \~100–500 créditos          |

**Compensación**: `/scrape` es el más barato pero requiere que conozcas la URL. `/agent` cuesta más pero se encarga del descubrimiento automáticamente.

Para ver los precios detallados, consulta [Precios de Firecrawl](https://firecrawl.dev/pricing).

***

<div id="migration-extract-agent">
  ## Migración: `/extract` → `/agent` [#migración-extract--agent]
</div>

Si actualmente estás utilizando `/extract`, la migración es muy sencilla:

**Antes (extract):**

```python
result = app.extract(
    urls=["https://example.com/*"],
    prompt="Extraer información del producto",
    schema=schema
)
```

**Después (agente):**

```python
result = app.agent(
    urls=["https://example.com"],  # Opcional - se puede omitir por completo
    prompt="Extract product information from example.com",
    schema=schema,
    model="spark-1-mini"  # or "spark-1-pro" for higher accuracy
)
```

La ventaja clave es que, con `/agent`, puedes prescindir por completo de las URL y simplemente describir lo que necesitas.

***

<div id="key-takeaways">
  ## Puntos clave [#puntos-clave]
</div>

1. **¿Sabes la URL exacta?** Usa `/scrape` con modo JSON: es la opción más barata (5 créditos/página), la más rápida (sincrónica) y la más predecible.

2. **¿Necesitas investigación autónoma?** Usa `/agent`: gestiona el descubrimiento automáticamente con 5 ejecuciones gratuitas al día y luego precios dinámicos según la complejidad.

3. **Migra de `/extract`** a `/agent` para proyectos nuevos: `/agent` es el sucesor con mejores capacidades.

4. **Equilibrio entre costo y conveniencia**: `/scrape` es lo más rentable cuando conoces tus URLs; `/agent` cuesta más, pero elimina el descubrimiento manual de URLs.

***

<div id="further-reading">
  ## Lecturas adicionales [#lecturas-adicionales]
</div>

* [Documentación de Agent](/es/features/agent)
* [Modelos de Agent](/es/features/models)
* [Documentación del modo JSON](/es/features/llm-extract)
* [Documentación de Extract](/es/features/extract)
* [Rastreo por lotes](/es/features/batch-scrape)