> ## Documentation Index
> Fetch the complete documentation index at: https://student-213fb9fc.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Node

> El SDK de Firecrawl para Node es un envoltorio de la API de Firecrawl que te ayuda a convertir sitios web en Markdown de forma sencilla.

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

Para instalar el SDK de Firecrawl para Node, puedes usar npm:

```js Node theme={null}
# npm install @mendable/firecrawl-js

import Firecrawl from '@mendable/firecrawl-js';

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

<div id="usage">
  ## Uso
</div>

1. Obtén una clave de API en [firecrawl.dev](https://firecrawl.dev)
2. Define la clave de API como una variable de entorno llamada `FIRECRAWL_API_KEY` o pásala como parámetro a la clase `FirecrawlApp`.

Aquí tienes un ejemplo de cómo usar el SDK con manejo de errores:

```js Node theme={null}
import Firecrawl from '@mendable/firecrawl-js';

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

// Extraer datos de un sitio web
const scrapeResponse = await firecrawl.scrape('https://firecrawl.dev', {
  formats: ['markdown', 'html'],
});

console.log(scrapeResponse)

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

console.log(crawlResponse)
```

<div id="scraping-a-url">
  ### Extracción de una URL
</div>

Para extraer una única URL con manejo de errores, usa el método `scrapeUrl`. Recibe la URL como parámetro y devuelve los datos extraídos como un diccionario.

```js Node.js theme={null}
// Extraer un sitio web:
const scrapeResult = await firecrawl.scrape('firecrawl.dev', { formats: ['markdown', 'html'] });

console.log(scrapeResult)
```

<div id="crawling-a-website">
  ### Rastreo de un sitio web
</div>

Para rastrear un sitio web con manejo de errores, usa el método `crawlUrl`. Recibe la URL inicial y parámetros opcionales como argumentos. El argumento `params` te permite especificar opciones adicionales para la tarea de rastreo, como el número máximo de páginas a rastrear, los dominios permitidos y el formato de salida. Consulta [Paginación](#pagination) para la paginación automática o manual y la configuración de límites.

```js Node theme={null}
const job = await firecrawl.crawl('https://docs.firecrawl.dev', { limit: 5, pollInterval: 1, timeout: 120 });
console.log(job.status);
```

<div id="sitemap-only-crawl">
  ### Rastreo solo del sitemap
</div>

Usa `sitemap: "only"` para rastrear únicamente las URL del sitemap (la URL inicial siempre se incluye y se omite la detección de enlaces HTML).

```js Node theme={null}
const job = await firecrawl.crawl('https://docs.firecrawl.dev', {
  sitemap: 'only',
  limit: 25,
});
console.log(job.status, job.data.length);
```

<div id="start-a-crawl">
  ### Iniciar un rastreo
</div>

Inicia un trabajo sin esperar usando `startCrawl`. Devuelve un `ID` de trabajo que puedes usar para comprobar el estado. Usa `crawl` cuando necesites un proceso bloqueante que espere hasta la finalización. Consulta [Paginación](#pagination) para el comportamiento y los límites de paginación.

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

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

Para verificar el estado de un trabajo de rastreo con manejo de errores, usa el método `checkCrawlStatus`. Recibe el `ID` como parámetro y devuelve el estado actual del trabajo de rastreo.

```js Node.js theme={null}
const estado = await firecrawl.getCrawlStatus("<id-de-rastreo>");
console.log(estado);
```

<div id="cancelling-a-crawl">
  ### Cancelar un rastreo
</div>

Para cancelar un trabajo de rastreo, usa el método `cancelCrawl`. Recibe como parámetro el ID del trabajo iniciado con `startCrawl` y devuelve el estado de la cancelación.

```js Node theme={null}
const ok = await firecrawl.cancelCrawl("<crawl-id>");
console.log("Cancelado:", ok);
```

<div id="mapping-a-website">
  ### Mapear un sitio web
</div>

Para mapear un sitio web con manejo de errores, utiliza el método `mapUrl`. Recibe la URL inicial como parámetro y devuelve los datos del mapeo como un diccionario.

```js Node theme={null}
const res = await firecrawl.map('https://firecrawl.dev', { limit: 10 });
console.log(res.links);
```

<div id="crawling-a-website-with-websockets">
  ### Rastreo de un sitio web con WebSockets
</div>

Para rastrear un sitio web con WebSockets, usa el método `crawlUrlAndWatch`. Recibe la URL inicial y parámetros opcionales como argumentos. El argumento `params` te permite especificar opciones adicionales para la tarea de rastreo, como el número máximo de páginas a rastrear, los dominios permitidos y el formato de salida.

```js Node theme={null}
import Firecrawl from '@mendable/firecrawl-js';

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();
```

<div id="pagination">
  ### Paginación
</div>

Los puntos de conexión de Firecrawl para crawl y batch devuelven una URL `next` cuando hay más datos disponibles. El SDK de Node realiza la paginación automáticamente por defecto y agrega todos los documentos; en ese caso, `next` será `null`. Puedes desactivar la paginación automática o establecer límites.

<div id="crawl">
  #### Rastreo
</div>

Usa el método auxiliar `crawl` para la forma más sencilla, o inicia un job y pagina manualmente.

<div id="simple-crawl-auto-pagination-default">
  ##### Rastreo simple (paginación automática, por defecto)
</div>

* Consulta el flujo por defecto en [Rastrear un sitio web](#crawling-a-website).

<div id="manual-crawl-with-pagination-control-single-page">
  ##### Rastreo manual con control de paginación (una sola página)
</div>

* Inicia un trabajo y luego recupera una página a la vez con `autoPaginate: false`.

```js Nodo theme={null}
const crawlStart = await firecrawl.startCrawl('https://docs.firecrawl.dev', { limit: 5 });
const crawlJobId = crawlStart.id;

const crawlSingle = await firecrawl.getCrawlStatus(crawlJobId, { autoPaginate: false });
console.log('rastreo de una sola página:', crawlSingle.status, 'docs:', crawlSingle.data.length, 'siguiente:', crawlSingle.next);
```

<div id="manual-crawl-with-limits-auto-pagination-early-stop">
  ##### Rastreo manual con límites (paginación automática + parada anticipada)
</div>

* Mantén la paginación automática activada, pero deténla antes con `maxPages`, `maxResults` o `maxWaitTime`.

```js Node theme={null}
const crawlLimited = await firecrawl.getCrawlStatus(crawlJobId, {
  autoPaginate: true,
  maxPages: 2,
  maxResults: 50,
  maxWaitTime: 15,
});
console.log('rastreo limitado:', crawlLimited.status, 'docs:', crawlLimited.data.length, 'siguiente:', crawlLimited.next);
```

<div id="batch-scrape">
  #### Scrape por lotes
</div>

Usa el método waiter `batchScrape`, o inicia un job y pagina manualmente.

<div id="simple-batch-scrape-auto-pagination-default">
  ##### Raspado por lotes simple (paginación automática, predeterminado)
</div>

* Consulta el flujo predeterminado en [Raspado por lotes](/es/features/batch-scrape).

<div id="manual-batch-scrape-with-pagination-control-single-page">
  ##### Raspado manual por lotes con control de paginación (una sola página)
</div>

* Inicia un job y luego recupera una página a la vez con `autoPaginate: false`.

```js Node theme={null}
const batchStart = await firecrawl.startBatchScrape([
  'https://docs.firecrawl.dev',
  'https://firecrawl.dev',
], { options: { formats: ['markdown'] } });
const batchJobId = batchStart.id;

const batchSingle = await firecrawl.getBatchScrapeStatus(batchJobId, { autoPaginate: false });
console.log('lote, una sola página:', batchSingle.status, 'docs:', batchSingle.data.length, 'siguiente:', batchSingle.next);
```

<div id="manual-batch-scrape-with-limits-auto-pagination-early-stop">
  ##### Extracción manual por lotes con límites (paginación automática + detención anticipada)
</div>

* Mantén la paginación automática activada, pero deténla antes con `maxPages`, `maxResults` o `maxWaitTime`.

```js Node theme={null}
const batchLimited = await firecrawl.getBatchScrapeStatus(batchJobId, {
  autoPaginate: true,
  maxPages: 2,
  maxResults: 100,
  maxWaitTime: 20,
});
console.log('lote limitado:', batchLimited.status, 'docs:', batchLimited.data.length, 'siguiente:', batchLimited.next);
```

<div id="browser">
  ## Browser
</div>

Inicia sesiones de navegador en la nube y ejecuta código de forma remota.

<div id="create-a-session">
  ### Crear una sesión
</div>

```js Node theme={null}
import Firecrawl from '@mendable/firecrawl-js';

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

const session = await firecrawl.browser({ ttl: 300 });
console.log(session.id);          // ID de sesión
console.log(session.cdpUrl);      // wss://cdp-proxy.firecrawl.dev/cdp/...
console.log(session.liveViewUrl); // https://liveview.firecrawl.dev/...
```

<div id="execute-code">
  ### Ejecutar código
</div>

```js Node theme={null}
const result = await firecrawl.browserExecute(session.id, {
  code: 'await page.goto("https://news.ycombinator.com")\ntitle = await page.title()\nprint(title)',
});
console.log(result.result); // "Hacker News"
```

Ejecutar JavaScript en lugar de Python:

```js Node theme={null}
const result = await firecrawl.browserExecute(session.id, {
  code: 'await page.goto("https://example.com"); const t = await page.title(); console.log(t);',
  language: "node",
});
```

Ejecutar Bash con agent-browser:

```js Node theme={null}
const result = await firecrawl.browserExecute(session.id, {
  code: "agent-browser open https://example.com && agent-browser snapshot",
  language: "bash",
});
```

<div id="profiles">
  ### Perfiles
</div>

Guarda y reutiliza el estado del navegador (cookies, localStorage, etc.) entre sesiones:

```js Node theme={null}
const session = await firecrawl.browser({
  ttl: 300,
  profile: {
    name: "my-profile",
    saveChanges: true,
  },
});
```

<div id="connect-via-cdp">
  ### Conectar mediante CDP
</div>

Para obtener control completo de Playwright, conecta directamente usando la URL de CDP:

```js Node theme={null}
import { chromium } from "playwright";

const browser = await chromium.connectOverCDP(session.cdpUrl);
const context = browser.contexts()[0];
const page = context.pages()[0] || await context.newPage();

await page.goto("https://example.com");
console.log(await page.title());

await browser.close();
```

<div id="list-close-sessions">
  ### Listar y cerrar sesiones
</div>

```js Node theme={null}
// Listar sesiones activas
const { sessions } = await firecrawl.listBrowsers({ status: "active" });
for (const s of sessions) {
  console.log(s.id, s.status, s.createdAt);
}

// Cerrar una sesión
await firecrawl.deleteBrowser(session.id);
```

<div id="error-handling">
  ## Manejo de errores
</div>

El SDK gestiona los errores devueltos por la API de Firecrawl y arroja las excepciones correspondientes. Si se produce un error durante una solicitud, se generará una excepción con un mensaje descriptivo. Los ejemplos anteriores muestran cómo manejar estos errores con bloques `try/catch`.