# Rastrear (/es/features/crawl)

<!-- agent-signals: reading_time_min: 15 · est_tokens: 9297 · updated: 2026-07-30 -->
Related: [Búsqueda](/es/features/search.md), [Highlights de búsqueda](/es/features/search-highlights.md), [Índice de investigación](/es/features/research.md), [scraping](/es/features/scrape.md), [Scraping más rápido](/es/features/fast-scraping.md), [Raspado en lote](/es/features/batch-scrape.md)

Rastrear envía una URL a Firecrawl y descubre y extrae de forma recursiva todas las subpáginas accesibles. Gestiona automáticamente sitemaps, renderizado de JavaScript y límites de tasa, y devuelve Markdown limpio o datos estructurados para cada página.

* Descubre páginas mediante sitemap y recorrido recursivo de enlaces
* Admite filtrado por ruta, límites de profundidad y control de subdominios/enlaces externos
* Devuelve resultados mediante polling, WebSocket o webhook

<Card title="Pruébalo en el Playground" icon="<svg xmlns=&#x22;http://www.w3.org/2000/svg&#x22; viewBox=&#x22;0 0 24 24&#x22; fill=&#x22;none&#x22;><path d=&#x22;M18.8906 12.846C18.5371 14.189 16.8667 15.138 13.5257 17.0361C10.296 18.8709 8.6812 19.7884 7.37983 19.4196C6.8418 19.2671 6.35159 18.9776 5.95624 18.5787C5 17.6139 5 15.7426 5 12C5 8.2574 5 6.3861 5.95624 5.42132C6.35159 5.02245 6.8418 4.73288 7.37983 4.58042C8.6812 4.21165 10.296 5.12907 13.5257 6.96393C16.8667 8.86197 18.5371 9.811 18.8906 11.154C19.0365 11.7084 19.0365 12.2916 18.8906 12.846Z&#x22; stroke=&#x22;currentColor&#x22; stroke-linejoin=&#x22;round&#x22; stroke-width=&#x22;1.5&#x22;/></svg>" href="https://www.firecrawl.dev/playground?endpoint=crawl">
  Prueba el rastreo en el playground interactivo, sin escribir código.
</Card>

<div id="installation">
  ## Instalación [#instalación]
</div>

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

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

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

    <CodeBlockTab value="Python">
      ```python  
      # pip install firecrawl-py

      from firecrawl import Firecrawl

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

    <CodeBlockTab value="Node">
      ```js  
      // npm install firecrawl

      import { Firecrawl } from 'firecrawl';

      const firecrawl = new Firecrawl({
        // No se necesita API key para comenzar — agrega una para obtener límites de tasa más altos:
        // apiKey: "fc-YOUR-API-KEY",
      });
      ```
    </CodeBlockTab>

    <CodeBlockTab value="CLI">
      ```bash  
      # Instalar globalmente con npm
      npm install -g firecrawl

      # Autenticar (configuración de una sola vez)
      firecrawl login
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<div id="basic-usage">
  ## Uso básico [#uso-básico]
</div>

Envía un trabajo de rastreo llamando a `POST /v2/crawl` con una URL inicial. El endpoint devuelve un ID de trabajo que usas para consultar los resultados.

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

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

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

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

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

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

      docs = firecrawl.crawl(url="https://docs.firecrawl.dev", limit=10)
      print(docs)
      ```
    </CodeBlockTab>

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

      const firecrawl = new Firecrawl({ apiKey: "fc-TU-CLAVE-DE-API" });

      const docs = await firecrawl.crawl('https://docs.firecrawl.dev', { limit: 10 });
      console.log(docs);
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      curl -s -X POST "https://api.firecrawl.dev/v2/crawl" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "url": "https://docs.firecrawl.dev",
          "limit": 10
        }'
      ```
    </CodeBlockTab>

    <CodeBlockTab value="CLI">
      ```bash  
      # Iniciar un trabajo de crawl (devuelve el ID del trabajo)
      firecrawl crawl https://firecrawl.dev

      # Wait for completion with progress
      firecrawl crawl https://firecrawl.dev --wait --progress --limit 100
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<Info>
  Cada página rastreada consume 1 crédito. El `limit` de rastreo predeterminado es de 10.000
  páginas. Antes de comenzar, el endpoint de rastreo comprueba que tus créditos restantes
  alcancen para cubrir el `limit`; si no es así, devuelve un error &#x2A;*402 (Pago requerido)**.
  Establece un `limit` más bajo que se ajuste al tamaño de rastreo previsto (por ejemplo, `limit: 100`) para
  evitarlo. Se aplican créditos adicionales para ciertas opciones: el modo JSON cuesta 4
  créditos adicionales por página, el proxy mejorado cuesta 4 créditos adicionales por
  página y el análisis de PDF cuesta 1 crédito por página de PDF.
</Info>

<div id="scrape-options">
  ### Opciones de scraping [#opciones-de-scraping]
</div>

Todas las opciones del [endpoint Scrape](/es/api-reference/endpoint/scrape) están disponibles en rastreo mediante `scrapeOptions` (JS) / `scrape_options` (Python). Se aplican a cada página que el crawler raspa, incluidos formatos, proxy, caché, acciones, ubicación y etiquetas.

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

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

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

      firecrawl = Firecrawl(api_key='fc-YOUR_API_KEY')

      # Crawl con opciones de scraping
      response = firecrawl.crawl('https://example.com',
          limit=100,
          scrape_options={
              'formats': [
                  'markdown',
                  { 'type': 'json', 'schema': { 'type': 'object', 'properties': { 'title': { 'type': 'string' } } } }
              ],
              'proxy': 'auto',
              'max_age': 600000,
              'only_main_content': True
          }
      )
      ```
    </CodeBlockTab>

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

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

      // Crawl con opciones de scraping
      const crawlResponse = await firecrawl.crawl('https://example.com', {
        limit: 100,
        scrapeOptions: {
          formats: [
            'markdown',
            {
              type: 'json',
              schema: { type: 'object', properties: { title: { type: 'string' } } },
            },
          ],
          proxy: 'auto',
          maxAge: 600000,
          onlyMainContent: true,
        },
      });
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<div id="checking-crawl-status">
  ## Verificar el estado del rastreo [#verificar-el-estado-del-rastreo]
</div>

Usa el ID del trabajo para consultar el estado del rastreo y recuperar los resultados.

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

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

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

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

    <CodeBlockTab value="Python">
      ```python  
      estado = firecrawl.get_crawl_status("<crawl-id>")
      print(estado)
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Node.js">
      ```js  
      const estado = await firecrawl.getCrawlStatus("<id-de-rastreo>");
      console.log(estado);
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      # Después de iniciar un rastreo, consulta el estado por jobId
      curl -s -X GET "https://api.firecrawl.dev/v2/crawl/<jobId>" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY"
      ```
    </CodeBlockTab>

    <CodeBlockTab value="CLI">
      ```bash  
      # Verificar estado del crawl usando el ID del trabajo
      firecrawl crawl <job-id>
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<Note>
  Los resultados de los trabajos están disponibles a través de la API durante 24 horas después de su finalización. Después de este periodo, aún puedes ver tu historial de rastreos y resultados en los [activity logs](https://www.firecrawl.dev/app/logs).
</Note>

<Note>
  Las páginas en el array `data` de los resultados del rastreo son páginas que Firecrawl extrajo correctamente, incluso si el sitio de destino devolvió un error HTTP como 404. El campo `metadata.statusCode` muestra el código de estado HTTP del sitio de destino. Para recuperar las páginas que Firecrawl no pudo extraer (por ejemplo, errores de red, tiempos de espera o bloqueos por robots.txt), usa el endpoint dedicado [Get Crawl Errors](/es/api-reference/endpoint/crawl-get-errors) (`GET /crawl/{id}/errors`).
</Note>

<div id="response-handling">
  ### Manejo de respuestas [#manejo-de-respuestas]
</div>

La respuesta varía según el estado del rastreo. Para respuestas incompletas o de gran tamaño que superen los 10 MB, se proporciona un parámetro de URL `next`. Debes solicitar esta URL para obtener los siguientes 10 MB de datos. Si el parámetro `next` no está presente, indica el final de los datos del rastreo.

<Info>
  Los parámetros `skip` y `next` solo son relevantes cuando se consume la API directamente.
  Si usas el SDK, la paginación se gestiona automáticamente y todos
  los resultados se devuelven de una vez.
</Info>

<CodeGroup>
  <CodeBlockTabs defaultValue="Raspando" groupId="completado+raspando">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Raspando">
        Raspando
      </CodeBlockTabsTrigger>

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

    <CodeBlockTab value="Raspando">
      ```json  
      {
        "status": "en proceso de scraping",
        "total": 36,
        "completed": 10,
        "creditsUsed": 10,
        "expiresAt": "2024-00-00T00:00:00.000Z",
        "next": "https://api.firecrawl.dev/v2/crawl/123-456-789?skip=10",
        "data": [
          {
            "markdown": "[Página principal de la documentación de Firecrawl![logo claro](https://mintlify.s3-us-west-1.amazonaws.com/firecrawl/logo/light.svg)!...",
            "html": "<!DOCTYPE html><html lang=\"en\" class=\"js-focus-visible lg:[--scroll-mt:9.5rem]\" data-js-focus-visible=\"\">...",
            "metadata": {
              "title": "Crea un 'chat con el sitio web' usando Groq Llama 3 | Firecrawl",
              "language": "en",
              "sourceURL": "https://docs.firecrawl.dev/learn/rag-llama3",
              "description": "Aprende a usar Firecrawl, Groq Llama 3 y LangChain para crear un bot de 'chat con tu sitio web'."
              "ogLocaleAlternate": [],
              "statusCode": 200
            }
          },
          ...
        ]
      }
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Completado">
      ```json  
      {
        "status": "completado",
        "total": 36,
        "completed": 36,
        "creditsUsed": 36,
        "expiresAt": "2024-00-00T00:00:00.000Z",
        "next": "https://api.firecrawl.dev/v2/crawl/123-456-789?skip=26",
        "data": [
          {
            "markdown": "[Página principal de la documentación de Firecrawl![logotipo claro](https://mintlify.s3-us-west-1.amazonaws.com/firecrawl/logo/light.svg)!...",
            "html": "<!DOCTYPE html><html lang=\"en\" class=\"js-focus-visible lg:[--scroll-mt:9.5rem]\" data-js-focus-visible=\"\">...",
            "metadata": {
              "title": "Crea un ‘chat con el sitio web’ usando Groq Llama 3 | Firecrawl",
              "language": "en",
              "sourceURL": "https://docs.firecrawl.dev/learn/rag-llama3",
              "description": "Aprende a usar Firecrawl, Groq Llama 3 y LangChain para crear un bot de ‘chat con tu sitio web’."
              "ogLocaleAlternate": [],
              "statusCode": 200
            }
          },
          ...
        ]
      }
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<div id="sdk-methods">
  ## Métodos del SDK [#métodos-del-sdk]
</div>

Hay dos maneras de usar `crawl` con el SDK.

<div id="crawl-and-wait">
  ### Rastrear y esperar [#rastrear-y-esperar]
</div>

El método `crawl` espera a que el rastreo termine y devuelve la respuesta completa. Gestiona la paginación automáticamente. Esto se recomienda para la mayoría de los casos de uso.

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

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

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

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

      # Rastrear un sitio web:
      crawl_status = firecrawl.crawl(
        'https://firecrawl.dev', 
        limit=100, 
        scrape_options=ScrapeOptions(formats=['markdown', 'html']),
        poll_interval=30
      )
      print(crawl_status)
      ```
    </CodeBlockTab>

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

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

      const crawlResponse = await firecrawl.crawl('https://firecrawl.dev', {
        limit: 100,
        scrapeOptions: {
          formats: ['markdown', 'html'],
        }
      })

      console.log(crawlResponse)
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

La respuesta incluye el estado del rastreo y todos los datos extraídos:

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

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

    <CodeBlockTab value="Python">
      ```bash  
      success=True
      status='completed'
      completed=100
      total=100
      creditsUsed=100
      expiresAt=datetime.datetime(2025, 4, 23, 19, 21, 17, tzinfo=TzInfo(UTC))
      next=None
      data=[
        Document(
          markdown='[Día 7 - Semana de lanzamiento III. Día de integraciones (del 14 al 20 de abril)](...',
          metadata={
            'title': '15 proyectos de web scraping con Python: de principiante a avanzado',
            ...
            'scrapeId': '97dcf796-c09b-43c9-b4f7-868a7a5af722',
            'sourceURL': 'https://www.firecrawl.dev/blog/python-web-scraping-projects',
            'url': 'https://www.firecrawl.dev/blog/python-web-scraping-projects',
            'statusCode': 200
          }
        ),
        ...
      ]
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Node">
      ```js  
      {
        success: true,
        status: "completed",
        completed: 100,
        total: 100,
        creditsUsed: 100,
        expiresAt: "2025-04-23T19:28:45.000Z",
        data: [
          {
            markdown: "[Day 7 - Launch Week III.Integrations DayApril ...",
            html: `<!DOCTYPE html><html lang="en" class="light" style="color...`,
            metadata: [Object],
          },
          ...
        ]
      }
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<div id="start-and-check-later">
  ### Iniciar y luego verificar el estado [#iniciar-y-luego-verificar-el-estado]
</div>

El método `startCrawl` / `start_crawl` devuelve de inmediato un ID de rastreo. Luego puedes verificar el estado manualmente. Esto es útil para rastreos de larga duración o lógica de sondeo personalizada.

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

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

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

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

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

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

      job = firecrawl.start_crawl(url="https://docs.firecrawl.dev", limit=10)
      print(job)

      # Comprueba el estado del rastreo
      status = firecrawl.get_crawl_status(job.id)
      print(status)
      ```
    </CodeBlockTab>

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

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

      const { id } = await firecrawl.startCrawl('https://docs.firecrawl.dev', { limit: 10 });
      console.log(id);

      // Comprueba el estado del rastreo
      const status = await firecrawl.getCrawlStatus(id);
      console.log(status);

      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      curl -s -X POST "https://api.firecrawl.dev/v2/crawl" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "url": "https://docs.firecrawl.dev",
          "limit": 10
        }'
      ```
    </CodeBlockTab>

    <CodeBlockTab value="CLI">
      ```bash  
      # Iniciar rastreo (asíncrono, devuelve ID de trabajo inmediatamente)
      firecrawl crawl https://firecrawl.dev --limit 100

      # Then check status later
      firecrawl crawl <job-id>
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

La respuesta inicial devuelve el ID del trabajo:

```json
{
  "success": true,
  "id": "123-456-789",
  "url": "https://api.firecrawl.dev/v2/crawl/123-456-789"
}
```

<div id="real-time-results-with-websocket">
  ## Resultados en tiempo real con WebSocket [#resultados-en-tiempo-real-con-websocket]
</div>

El método watcher proporciona actualizaciones en tiempo real a medida que se rastrean las páginas. Inicia un rastreo y luego suscríbete a los eventos para procesar los datos de inmediato.

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

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

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

      async def main():
          firecrawl = AsyncFirecrawl(api_key="fc-YOUR-API-KEY")

          # Iniciar un rastreo primero
          started = await firecrawl.start_crawl("https://firecrawl.dev", limit=5)

          # Monitorear actualizaciones (snapshots) hasta estado terminal
          async for snapshot in firecrawl.watcher(started.id, kind="crawl", poll_interval=2, timeout=120):
              if snapshot.status == "completed":
                  print("COMPLETADO", snapshot.status)
                  for doc in snapshot.data:
                      print("DOC", doc.metadata.source_url if doc.metadata else None)
              elif snapshot.status == "failed":
                  print("ERROR", snapshot.status)
              else:
                  print("ESTADO", snapshot.status, snapshot.completed, "/", snapshot.total)

      asyncio.run(main())
      ```
    </CodeBlockTab>

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

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

      // Inicia un rastreo y luego míralo
      const { id } = await firecrawl.startCrawl('https://mendable.ai', {
        excludePaths: ['blog/*'],
        limit: 5,
      });

      const watcher = firecrawl.watcher(id, { kind: 'crawl', pollInterval: 2, timeout: 120 });

      watcher.on('document', (doc) => {
        console.log('DOC', doc);
      });

      watcher.on('error', (err) => {
        console.error('ERR', err?.error || err);
      });

      watcher.on('done', (state) => {
        console.log('DONE', state.status);
      });

      // Comienza a mirar (WS con alternativa HTTP)
      await watcher.start();
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<div id="webhooks">
  ## Webhooks [#webhooks]
</div>

Puedes configurar webhooks para recibir notificaciones en tiempo real a medida que avanza el rastreo. Esto te permite procesar las páginas conforme se van extrayendo, en lugar de esperar a que finalice todo el rastreo.

```bash title="cURL"
curl -X POST https://api.firecrawl.dev/v2/crawl \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer YOUR_API_KEY' \
    -d '{
      "url": "https://docs.firecrawl.dev",
      "limit": 100,
      "webhook": {
        "url": "https://tu-dominio.com/webhook",
        "metadata": {
          "any_key": "any_value"
        },
        "events": ["started", "page", "completed"]
      }
    }'
```

<div id="event-types">
  ### Tipos de eventos [#tipos-de-eventos]
</div>

| Evento            | Descripción                                     |
| ----------------- | ----------------------------------------------- |
| `crawl.started`   | Se emite cuando comienza el rastreo             |
| `crawl.page`      | Se emite por cada página extraída correctamente |
| `crawl.completed` | Se emite cuando finaliza el rastreo             |
| `crawl.failed`    | Se emite si el rastreo encuentra un error       |

<div id="payload">
  ### Carga útil [#carga-útil]
</div>

```json
{
  "success": true,
  "type": "crawl.page",
  "id": "crawl-job-id",
  "data": [...], // Datos de página para eventos 'page'
  "metadata": {}, // Your custom metadata
  "error": null
}
```

<div id="verifying-webhook-signatures">
  ### Verificación de firmas de webhooks [#verificación-de-firmas-de-webhooks]
</div>

Cada solicitud de webhook de Firecrawl incluye un encabezado `X-Firecrawl-Signature` que contiene una firma HMAC-SHA256. Verifica siempre esta firma para asegurarte de que el webhook sea auténtico y no haya sido manipulado.

1. Obtén tu secreto de webhook en la [pestaña Advanced](https://www.firecrawl.dev/app/settings?tab=advanced) de la configuración de tu cuenta
2. Extrae la firma del encabezado `X-Firecrawl-Signature`
3. Calcula el HMAC-SHA256 del cuerpo sin procesar (raw) de la solicitud usando tu secreto
4. Compárala con el encabezado de la firma usando una función segura frente a ataques de temporización

<Warning>
  Nunca proceses un webhook sin verificar primero su firma. El encabezado `X-Firecrawl-Signature` contiene la firma en el formato: `sha256=abc123def456...`
</Warning>

Para ver ejemplos completos de implementación en JavaScript y Python, consulta la [documentación de seguridad de webhooks](/es/webhooks/security). Para consultar la documentación completa sobre webhooks, incluidos payloads de eventos detallados, estructura de payloads, configuración avanzada y solución de problemas, consulta la [documentación de webhooks](/es/webhooks/overview).

<div id="configuration-reference">
  ## Referencia de configuración [#referencia-de-configuración]
</div>

El conjunto completo de parámetros disponibles al enviar un trabajo de rastreo:

| Parámetro               | Tipo       | Predeterminado | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| ----------------------- | ---------- | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `url`                   | `string`   | (obligatorio)  | La URL inicial desde la que se realizará el rastreo                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `limit`                 | `integer`  | `10000`        | Número máximo de páginas que se rastrearán                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `maxDiscoveryDepth`     | `integer`  | (ninguno)      | Profundidad máxima desde la URL raíz según los saltos de descubrimiento de enlaces, no la cantidad de segmentos `/` en la URL. Cada vez que se encuentra una nueva URL en una página, se le asigna una profundidad una unidad mayor que la de la página en la que fue descubierta. El sitio raíz y las páginas del sitemap tienen una profundidad de descubrimiento de 0. Las páginas en la profundidad máxima igualmente se extraen, pero no se siguen los enlaces que contienen. |
| `includePaths`          | `string[]` | (ninguno)      | Patrones regex de rutas de URL que se incluirán. Solo se rastrean las rutas que coinciden.                                                                                                                                                                                                                                                                                                                                                                                         |
| `excludePaths`          | `string[]` | (ninguno)      | Patrones regex de rutas de URL que se excluirán del rastreo                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `regexOnFullURL`        | `boolean`  | `false`        | Hace coincidir `includePaths`/`excludePaths` con la URL completa (incluidos los parámetros de consulta) en lugar de solo con la ruta                                                                                                                                                                                                                                                                                                                                               |
| `crawlEntireDomain`     | `boolean`  | `false`        | Sigue enlaces internos a URL del mismo nivel o superiores, no solo a rutas hijas                                                                                                                                                                                                                                                                                                                                                                                                   |
| `allowSubdomains`       | `boolean`  | `false`        | Sigue enlaces a subdominios del dominio principal                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `allowExternalLinks`    | `boolean`  | `false`        | Sigue enlaces a sitios web externos                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `sitemap`               | `string`   | `"include"`    | Gestión del sitemap: `"include"` (predeterminado), `"skip"` o `"only"`                                                                                                                                                                                                                                                                                                                                                                                                             |
| `ignoreQueryParameters` | `boolean`  | `false`        | Evita volver a extraer la misma ruta con distintos parámetros de consulta                                                                                                                                                                                                                                                                                                                                                                                                          |
| `ignoreRobotsTxt`       | `boolean`  | `false`        | Ignora las reglas de robots.txt del sitio web. **Solo Enterprise** — contacta con [support@firecrawl.com](mailto:support@firecrawl.com) para habilitarlo.                                                                                                                                                                                                                                                                                                                          |
| `robotsUserAgent`       | `string`   | (ninguno)      | Cadena User-Agent personalizada para evaluar robots.txt. Cuando se establece, robots.txt se obtiene con este User-Agent y las reglas se comparan con él en lugar del predeterminado. **Solo Enterprise** — contacta con [support@firecrawl.com](mailto:support@firecrawl.com) para habilitarlo.                                                                                                                                                                                    |
| `delay`                 | `number`   | (ninguno)      | Retraso en segundos entre extracciones para respetar los límites de tasa. Establecer esto fuerza la concurrencia a 1.                                                                                                                                                                                                                                                                                                                                                              |
| `maxConcurrency`        | `integer`  | (ninguno)      | Número máximo de extracciones concurrentes. De forma predeterminada, usa el límite de concurrencia de tu equipo.                                                                                                                                                                                                                                                                                                                                                                   |
| `scrapeOptions`         | `object`   | (ninguno)      | Opciones aplicadas a cada página extraída (formatos, proxy, caché, acciones, etc.)                                                                                                                                                                                                                                                                                                                                                                                                 |
| `webhook`               | `object`   | (ninguno)      | Configuración del webhook para notificaciones en tiempo real                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `prompt`                | `string`   | (ninguno)      | Prompt en lenguaje natural para generar opciones de rastreo. Los parámetros establecidos explícitamente anulan los equivalentes generados.                                                                                                                                                                                                                                                                                                                                         |

<div id="important-details">
  ## Detalles importantes [#detalles-importantes]
</div>

<Warning>
  De forma predeterminada, crawl ignora los subenlaces que no son descendientes de la URL que proporcionas. Por ejemplo, `website.com/other-parent/blog-1` no se devolvería si hicieras crawl de `website.com/blogs/`. Usa el parámetro `crawlEntireDomain` para incluir rutas hermanas y superiores. Para hacer crawl de subdominios como `blog.website.com` al hacer crawl de `website.com`, usa el parámetro `allowSubdomains`.
</Warning>

* **Descubrimiento del sitemap**: De forma predeterminada, el crawler incluye el sitemap del sitio web para descubrir URL (`sitemap: "include"`). Si estableces `sitemap: "skip"`, solo se encontrarán las páginas accesibles mediante enlaces HTML desde la URL raíz. Recursos como PDF o páginas muy anidadas incluidas en el sitemap, pero no enlazadas directamente desde el HTML, no se encontrarán. Para obtener la máxima cobertura, mantén la configuración predeterminada.
* **Uso de créditos**: Cada página rastreada cuesta 1 crédito. El modo JSON añade 4 créditos por página, el proxy mejorado añade 4 créditos por página y el análisis de PDF cuesta 1 crédito por cada página del PDF.
* **Expiración de resultados**: Los resultados del trabajo están disponibles a través de la API durante 24 horas después de completarse. Después de ese plazo, consulta los resultados en los [registros de actividad](https://www.firecrawl.dev/app/logs).
* **Errores de crawl**: El array `data` contiene las páginas que Firecrawl extrajo correctamente. Usa el endpoint [Get Crawl Errors](/es/api-reference/endpoint/crawl-get-errors) para recuperar las páginas que fallaron debido a errores de red, tiempos de espera o bloqueos de robots.txt.
* **Resultados no deterministas**: Los resultados de crawl pueden variar entre ejecuciones con la misma configuración. Las páginas se extraen de forma concurrente, por lo que el orden en que se descubren los enlaces depende de la latencia de la red y de qué páginas terminan de cargarse primero. Esto significa que diferentes ramas de un sitio pueden explorarse en distinta medida cerca del límite de profundidad, especialmente con valores altos de `maxDiscoveryDepth`. Para obtener resultados más deterministas, establece `maxConcurrency` en `1` o usa `sitemap: "only"` si el sitio tiene un sitemap completo.

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