> ## Documentation Index
> Fetch the complete documentation index at: https://firecrawl-docs-remove-capabilities-from-sidebar.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# CLI

> Las skills de Firecrawl son una forma sencilla de que agentes de IA como Codex, Claude Code, Cursor y OpenCode usen Firecrawl a través de la CLI.

Busca, haz scraping, interactúa, rastrea, mapea y ejecuta trabajos de agentes directamente desde la terminal. La CLI de Firecrawl funciona por sí sola o con skills que los agentes de codificación con IA, como Codex, Claude Code, Cursor y OpenCode, pueden descubrir y usar automáticamente.

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

Si estás usando un agente de IA como Codex, Claude Code, Cursor u OpenCode, puedes instalar los Skills de Firecrawl a continuación y el agente los configurará por ti.

```bash theme={null}
npx -y firecrawl-cli@latest init --all --browser
```

* `--all` omite la selección de agente e inicializa todos los agentes detectados
* `--browser` abre el navegador automáticamente para la autenticación de Firecrawl

<Note>
  Después de instalar los Skills, reinicia tu agente para que pueda detectarlos.
</Note>

También puedes instalar manualmente la CLI de Firecrawl de forma global usando npm:

```bash CLI theme={null}
# Instalar globalmente con npm
npm install -g firecrawl-cli
```

<div id="authentication">
  ## Autenticación
</div>

Antes de usar la CLI, debes autenticarte con tu clave de API de Firecrawl.

<Note>
  **Algunos comandos de la CLI funcionan sin iniciar sesión.** Si no tienes ninguna clave de API configurada, los comandos compatibles usan el nivel gratuito sin clave: gratis, pero con límites por IP. Consulta [Límites de tasa](/es/rate-limits#keyless-no-api-key) para ver la lista actual de comandos sin clave y las advertencias. [Regístrate para obtener una clave gratuita](https://firecrawl.dev) y consigue 1.000 créditos y límites más altos; la CLI la usará automáticamente una vez configurada.
</Note>

<div id="login">
  ### Inicio de sesión
</div>

```bash CLI theme={null}
# Inicio de sesión interactivo (abre el navegador o solicita la clave API)
firecrawl login

# Inicio de sesión con autenticación por navegador (recomendado para agentes)
firecrawl login --browser

# Inicio de sesión con clave API directamente
firecrawl login --api-key fc-YOUR-API-KEY

# O establecer mediante variable de entorno
export FIRECRAWL_API_KEY=fc-YOUR-API-KEY
```

<div id="view-configuration">
  ### Ver la configuración
</div>

```bash CLI theme={null}
# Ver configuración actual y estado de autenticación
firecrawl view-config
```

<div id="logout">
  ### Cerrar sesión
</div>

```bash CLI theme={null}
# Borrar credenciales almacenadas
firecrawl logout
```

<div id="connect-the-cli-to-self-hosted-firecrawl">
  ### Conecta la CLI a Firecrawl autogestionado
</div>

Primero, consigue que funcione un scraping con la [guía de autogestión](/es/contributing/self-host). Después, configura la CLI para que use esa API con `--api-url` o `FIRECRAWL_API_URL`:

```bash CLI theme={null}
# Usa una instancia local de Firecrawl (no requiere clave de API)
firecrawl --api-url http://localhost:3002 scrape https://example.com

# Or set via environment variable
export FIRECRAWL_API_URL=http://localhost:3002
firecrawl scrape https://example.com

# Configure and persist the custom API URL
firecrawl config --api-url http://localhost:3002
```

Al utilizar una URL de API personalizada en lugar de `https://api.firecrawl.dev`, la CLI omite la autenticación mediante clave de API de Firecrawl Cloud. Esto coincide con el inicio rápido para redes de confianza, donde `USE_DB_AUTHENTICATION=false`.

<Warning>
  Mantén una API sin autenticación en una red de confianza. Si añades un proxy de autenticación
  u otra capa de control de acceso, verifica que la CLI pueda enviar las
  credenciales que requiera esa capa antes de depender de esta opción.
</Warning>

La CLI solo puede invocar las capacidades habilitadas en tu implementación. Consulta la [compatibilidad de funcionalidades autogestionadas](/es/contributing/self-host#self-hosted-feature-support) antes de usar comandos exclusivos de Cloud o que dependan de proveedores.

<div id="check-status">
  ### Comprobar estado
</div>

Comprueba la instalación, la autenticación y consulta los límites de velocidad (rate limits):

```bash CLI theme={null}
firecrawl --status
```

Genera la salida cuando esté listo:

```
  🔥 firecrawl cli v1.16.2

  ● Authenticated via FIRECRAWL_API_KEY
  Concurrency: 0/100 jobs (parallel scrape limit)
  Credits: 500,000 remaining
```

* **Concurrencia**: Máximo de tareas en paralelo. Ejecuta operaciones en paralelo lo más cerca posible de este límite, pero sin superarlo.
* **Créditos**: Créditos de API restantes. Cada operación de scrape/crawl consume créditos.

<div id="commands">
  ## Comandos
</div>

<Note>
  El comando oculto `firecrawl browser` ha quedado obsoleto para los flujos de trabajo de agentes. Usa primero `firecrawl scrape <url>` y luego `firecrawl interact ...` con la sesión de scraping resultante.
</Note>

<div id="scrape">
  ### Scrape
</div>

Extrae el contenido de una única URL en distintos formatos.

<Tip>
  Usa `--only-main-content` para obtener una salida limpia sin navegación, pies de página ni anuncios. Se recomienda para la mayoría de los casos de uso en los que solo quieres el artículo o el contenido principal de la página.
</Tip>

```bash CLI theme={null}
# Extraer datos de una URL (predeterminado: salida en markdown)
firecrawl https://example.com

# O usar el comando explícito de scrape
firecrawl scrape https://example.com

# Recomendado: usar --only-main-content para obtener una salida limpia sin navegación/pie de página
firecrawl https://example.com --only-main-content
```

<div id="output-formats">
  #### Formatos de salida
</div>

```bash CLI theme={null}
# Get HTML output
firecrawl https://example.com --html

# Multiple formats (returns JSON)
firecrawl https://example.com --format markdown,links

# Get images from a page
firecrawl https://example.com --format images

# Get a summary of the page content
firecrawl https://example.com --format summary

# Track changes on a page
firecrawl https://example.com --format changeTracking

# Formatos disponibles: markdown, html, rawHtml, links, screenshot, json, images, summary, changeTracking, attributes, branding, product
```

<div id="scrape-options">
  #### Opciones de Scrape
</div>

```bash CLI theme={null}
# Extraer solo el contenido principal (elimina navegación y pies de página)
firecrawl https://example.com --only-main-content

# Wait for JavaScript rendering
firecrawl https://example.com --wait-for 3000

# Take a screenshot
firecrawl https://example.com --screenshot

# Extraer JSON estructurado con un esquema
firecrawl https://example.com --format json --schema '{"type":"object","properties":{"title":{"type":"string"}}}'

# Ejecutar acciones de scraping ligeras antes de la extracción
firecrawl https://example.com --actions '[{"type":"wait","milliseconds":1000}]'

# Seleccionar modo de proxy
firecrawl https://example.com --proxy basic

# Redactar información de identificación personal
firecrawl https://example.com --redact-pii

# Include/exclude specific HTML tags
firecrawl https://example.com --include-tags article,main
firecrawl https://example.com --exclude-tags nav,footer

# Save output to file
firecrawl https://example.com -o output.md

# Pretty print JSON output
firecrawl https://example.com --format markdown,links --pretty

# Force JSON output even with single format
firecrawl https://example.com --json

# Show request timing information
firecrawl https://example.com --timing
```

**Opciones disponibles:**

| Opción | Alias | Descripción |
| - | - | - |
| `--url <url>` | `-u` | URL para hacer scrape (alternativa al argumento posicional) |
| `--format <formats>` | `-f` | Formatos de salida (separados por comas): `markdown`, `html`, `rawHtml`, `links`, `screenshot`, `json`, `images`, `summary`, `seguimientoDeCambios`, `attributes`, `branding` |
| `--html` | `-H` | Atajo para `--format html` |
| `--only-main-content` | | Extraer solo el contenido principal |
| `--wait-for <ms>` | | Tiempo de espera en milisegundos para el renderizado de JS |
| `--screenshot` | | Tomar una captura de pantalla |
| `--full-page-screenshot` | | Tomar una captura de pantalla de la página completa |
| `--include-tags <tags>` | | Etiquetas HTML a incluir (separadas por comas) |
| `--exclude-tags <tags>` | | Etiquetas HTML a excluir (separadas por comas) |
| `--schema <json>` | | esquema JSON para extracción estructurada |
| `--schema-file <path>` | | Ruta al archivo de esquema JSON |
| `--actions <json>` | | Array JSON de acciones para ejecutar durante el scrape |
| `--actions-file <path>` | | Ruta al archivo JSON de acciones |
| `--proxy <proxy>` | | Modo proxy para scraping (por ejemplo, `auto` o `basic`) |
| `--redact-pii` | | Redactar la información de identificación personal del contenido devuelto |
| `--output <path>` | `-o` | Guardar la salida en un archivo |
| `--json` | | Forzar salida JSON incluso con un solo formato |
| `--pretty` | | Imprimir el JSON de salida con formato |
| `--timing` | | Mostrar el tiempo de la solicitud y otra información útil |

***

<div id="search">
  ### Buscar
</div>

Busca en la web y, opcionalmente, hace scraping de los resultados.

```bash CLI theme={null}
# Buscar en la web
firecrawl search "web scraping tutorials"

# Limitar resultados
firecrawl search "AI news" --limit 10

# Imprimir resultados con formato
firecrawl search "machine learning" --pretty
```

<div id="search-options">
  #### Opciones de búsqueda
</div>

```bash CLI theme={null}
# Search specific sources
firecrawl search "AI" --sources web,news,images

# Search with category filters
firecrawl search "react hooks" --categories developer
firecrawl search "machine learning" --categories research,pdf

# Time-based filtering
firecrawl search "tech news" --tbs qdr:h   # Last hour
firecrawl search "tech news" --tbs qdr:d   # Last day
firecrawl search "tech news" --tbs qdr:w   # Última semana
firecrawl search "tech news" --tbs qdr:m   # Last month
firecrawl search "tech news" --tbs qdr:y   # Last year

# Location-based search
firecrawl search "restaurants" --location "Berlin,Germany" --country DE

# Search and scrape results
firecrawl search "documentation" --scrape --scrape-formats markdown

# Save to file
firecrawl search "firecrawl" --pretty -o results.json
```

**Opciones disponibles:**

| Opción | Descripción |
| - | - |
| `--limit <number>` | Número máximo de resultados (predeterminado: 5, máximo: 100) |
| `--sources <sources>` | Fuentes de búsqueda: `web`, `images`, `news` (separadas por comas) |
| `--categories <categories>` | Filtrar por categoría: `research`, `pdf`, `developer` (separadas por comas) |
| `--tbs <value>` | Filtro de tiempo: `qdr:h` (hora), `qdr:d` (día), `qdr:w` (semana), `qdr:m` (mes), `qdr:y` (año) |
| `--location <location>` | Segmentación geográfica (p. ej., "Berlin,Germany") |
| `--country <code>` | Código de país ISO (predeterminado: US) |
| `--timeout <ms>` | Tiempo máximo de espera en milisegundos (predeterminado: 60000) |
| `--ignore-invalid-urls` | Excluir URLs no válidas para otros endpoints de Firecrawl |
| `--scrape` | Hacer scraping de resultados de búsqueda |
| `--scrape-formats <formats>` | formatos para contenido obtenido mediante scraping |
| `--only-main-content` | Incluir solo el contenido principal al scraping (predeterminado: true) |
| `--json` | Salida como JSON |
| `--output <path>` | Guardar la salida en un archivo |
| `--pretty` | Imprimir salida JSON con formato legible |

***

<div id="developer">
  ### Desarrollador
</div>

Busca en el [Índice para desarrolladores](/es/features/developer): issues, pull requests fusionadas y archivos README de repositorios de código públicos, además de sitios de documentación seleccionados.

```bash CLI theme={null}
firecrawl developer "how do I configure retries" --limit 10
```

**Opciones disponibles:**

| Opción | Descripción |
| - | - |
| `--limit <number>` | Número de resultados que se devolverán (predeterminado: 10, máx.: 100) |
| `--skills-only` | Busca solo archivos de skills de agentes indexados (predeterminado: false) |
| `--json` | Muestra la salida como JSON compacto |
| `--output <path>` | Guarda la salida en un archivo |
| `--pretty` | Formatea la salida JSON para facilitar su lectura |

***

<div id="map">
  ### Map
</div>

Obtén rápidamente todas las URL de un sitio web.

```bash CLI theme={null}
# Descubre todas las URLs de un sitio web
firecrawl map https://example.com

# Output as JSON
firecrawl map https://example.com --json

# Limit number of URLs
firecrawl map https://example.com --limit 500
```

<div id="map-options">
  #### Opciones de mapeo
</div>

```bash CLI theme={null}
# Filter URLs by search query
firecrawl map https://example.com --search "blog"

# Include subdomains
firecrawl map https://example.com --include-subdomains

# Control sitemap usage
firecrawl map https://example.com --sitemap include   # Use sitemap
firecrawl map https://example.com --sitemap skip      # Skip sitemap
firecrawl map https://example.com --sitemap only      # Solo usar sitemap

# Ignore query parameters (dedupe URLs)
firecrawl map https://example.com --ignore-query-parameters

# Wait for map to complete with timeout
firecrawl map https://example.com --wait --timeout 60

# Save to file
firecrawl map https://example.com -o urls.txt
firecrawl map https://example.com --json --pretty -o urls.json
```

**Opciones disponibles:**

| Opción | Descripción |
| - | - |
| `--url <url>` | URL que se va a mapear (alternativa al argumento posicional) |
| `--limit <number>` | Número máximo de URLs a descubrir |
| `--search <query>` | Filtrar URLs por consulta de búsqueda |
| `--sitemap <mode>` | Manejo del sitemap: `include`, `skip`, `only` |
| `--include-subdomains` | Incluir subdominios |
| `--ignore-query-parameters` | Tratar URLs con distintos parámetros de consulta como la misma |
| `--wait` | Esperar a que finalice el mapeo |
| `--timeout <seconds>` | Tiempo de espera en segundos |
| `--json` | Salida en formato JSON |
| `--output <path>` | Guardar la salida en un archivo |
| `--pretty` | Imprimir la salida JSON con formato legible |

***

<div id="interact">
  ### Interact
</div>

Haz scraping de una página y luego interactúa con ella usando lenguaje natural o código. Interact usa el scraping más reciente de forma predeterminada, o puedes pasar un ID de scraping específico.

```bash CLI theme={null}
# 1. Scrape la página principal de Amazon (el ID de scrape se guarda automáticamente)
firecrawl scrape https://www.amazon.com

# 2. Interactúa — busca un producto y obtén su precio
firecrawl interact "Search for iPhone 16 Pro Max"
firecrawl interact "Click on the first result and tell me the price"

# 3. Detén la sesión
firecrawl interact stop
```

**Opciones disponibles:**

| Opción | Descripción |
| - | - |
| `-p, --prompt <text>` | Prompt de IA (alternativa al argumento posicional) |
| `-c, --code <code>` | Código que se ejecutará en la sesión activa de la página |
| `-s, --scrape-id <id>` | ID de trabajo de scraping (predeterminado: último scraping) |
| `--python` | Ejecuta el código como Python/Playwright |
| `--node` | Ejecuta el código como Node.js/Playwright (predeterminado) |
| `--bash` | Ejecuta el código como Bash |
| `--timeout <seconds>` | Timeout en segundos (1-300, predeterminado: 30) |
| `--output <path>` | Guarda la salida en un archivo |
| `--json` | Salida en formato JSON |

***

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

Rastrea todo un sitio web a partir de una URL.

```bash CLI theme={null}
# Iniciar un rastreo (devuelve el ID del trabajo inmediatamente)
firecrawl crawl https://example.com

# Wait for crawl to complete
firecrawl crawl https://example.com --wait

# Wait with progress indicator
firecrawl crawl https://example.com --wait --progress
```

<div id="check-crawl-status">
  #### Consultar el estado del rastreo
</div>

```bash CLI theme={null}
# Verificar estado del crawl usando el ID del trabajo
firecrawl crawl <job-id>

# Ejemplo con un ID de trabajo real
firecrawl crawl 550e8400-e29b-41d4-a716-446655440000
```

<div id="crawl-options">
  #### Opciones de rastreo
</div>

```bash CLI theme={null}
# Limit crawl depth and pages
firecrawl crawl https://example.com --limit 100 --max-depth 3 --wait

# Include only specific paths
firecrawl crawl https://example.com --include-paths /blog,/docs --wait

# Exclude specific paths
firecrawl crawl https://example.com --exclude-paths /admin,/login --wait

# Include subdomains
firecrawl crawl https://example.com --allow-subdomains --wait

# Crawl entire domain
firecrawl crawl https://example.com --crawl-entire-domain --wait

# Rate limiting
firecrawl crawl https://example.com --delay 1000 --max-concurrency 2 --wait

# Pasar opciones de scraping a cada página rastreada
firecrawl crawl https://example.com --scrape-options '{"formats":["markdown"],"onlyMainContent":true}'

# Enviar eventos de finalización de rastreo a un webhook
firecrawl crawl https://example.com --webhook '{"url":"https://example.com/webhook","events":["completed"]}'

# Cancelar un rastreo activo
firecrawl crawl <job-id> --cancel

# Intervalo de consulta y tiempo de espera personalizados
firecrawl crawl https://example.com --wait --poll-interval 10 --timeout 300

# Save results to file
firecrawl crawl https://example.com --wait --pretty -o results.json
```

**Opciones disponibles:**

| Opción | Descripción |
| - | - |
| `--url <url>` | URL a rastrear (alternativa al argumento posicional) |
| `--wait` | Esperar a que el rastreo termine |
| `--progress` | Mostrar indicador de progreso mientras se espera |
| `--poll-interval <seconds>` | Intervalo de sondeo (por defecto: 5) |
| `--timeout <seconds>` | Tiempo máximo de espera |
| `--status` | Consultar el estado de un trabajo de rastreo existente |
| `--limit <number>` | Número máximo de páginas a rastrear |
| `--max-depth <number>` | Profundidad máxima de rastreo |
| `--include-paths <paths>` | Rutas a incluir (separadas por comas) |
| `--exclude-paths <paths>` | Rutas a excluir (separadas por comas) |
| `--sitemap <mode>` | Manejo del sitemap: `include`, `skip`, `only` |
| `--allow-subdomains` | Incluir subdominios |
| `--allow-external-links` | Seguir enlaces externos |
| `--crawl-entire-domain` | Rastrear todo el dominio |
| `--ignore-query-parameters` | Considerar URLs con distintos parámetros como iguales |
| `--delay <ms>` | Retraso entre solicitudes |
| `--max-concurrency <n>` | Número máximo de solicitudes concurrentes |
| `--scrape-options <json>` | Opciones de scraping en JSON que se pasan a cada página |
| `--scrape-options-file <path>` | Ruta al archivo JSON de opciones de scraping |
| `--webhook <url-or-json>` | URL o configuración del webhook |
| `--cancel` | Cancelar un trabajo de rastreo activo mediante el ID de trabajo |
| `--output <path>` | Guardar el resultado en un archivo |
| `--pretty` | Imprimir la salida JSON con formato legible |

***

<div id="monitor">
  ### Monitor
</div>

Crea scrapes o crawls recurrentes que calculen las diferencias de cada ejecución con respecto a la instantánea anterior. Añade un objetivo cuando quieras que Firecrawl determine qué páginas modificadas son relevantes para tu caso de uso.

```bash CLI theme={null}
firecrawl monitor create --name "Hacker News AI" \
  --schedule "every 30 minutes" \
  --goal "Alert when a new Hacker News story related to AI enters the top 10. Ignore changes to stories that are not about AI. Do not alert on changes outside the top 10." \
  --page https://news.ycombinator.com

firecrawl monitor run <monitorId>
firecrawl monitor checks <monitorId> --limit 10
firecrawl monitor check <monitorId> <checkId> --page-status changed
firecrawl monitor update <monitorId> \
  --goal "Alert when a new Hacker News story related to AI enters the top 10. Do not alert on changes outside the top 10."
firecrawl monitor delete <monitorId>
```

Los objetivos del monitor deben ser breves y fieles a la intención del usuario: indica qué debe activar una alerta, reformula cualquier alcance especificado e incluye exclusiones solo cuando sean obvias o se soliciten explícitamente. Si el usuario pide "cualquier cambio", mantén el objetivo amplio.

**Opciones disponibles:**

| Opción | Descripción |
| - | - |
| `--name <name>` | Nombre del monitor |
| `--goal <goal>` | Objetivo para evaluar cambios significativos |
| `--cron <expression>` | Programación cron, por ejemplo `*/30 * * * *` |
| `--schedule <text>` | Programación en lenguaje natural, por ejemplo `hourly` |
| `--timezone <tz>` | Zona horaria de la programación, predeterminada `UTC` |
| `--page <url>` | URL de una sola página para hacer scraping en cada comprobación |
| `--scrape-urls <list>` | URLs de páginas separadas por comas para hacer scraping en cada comprobación |
| `--crawl-url <url>` | URL raíz de un objetivo de rastreo |
| `--webhook-url <url>` | Destino del webhook |
| `--webhook-events <list>` | Eventos del monitor separados por comas |
| `--email <list>` | Destinatarios de correo electrónico separados por comas |
| `--retention-days <n>` | Periodo de retención de snapshots |
| `--page-status <state>` | Filtrar páginas en `monitor check` |
| `--state <state>` | Establecer el estado del monitor en `monitor update`: active/paused |

***

<div id="agent">
  ### Agente
</div>

Busca y recopila datos de la web usando indicaciones en lenguaje natural.

```bash CLI theme={null}
# Uso básico - las URLs son opcionales
firecrawl agent "Find the top 5 AI startups and their funding amounts" --wait

# Focus on specific URLs
firecrawl agent "Compare pricing plans" --urls https://slack.com/pricing,https://teams.microsoft.com/pricing --wait

# Use a schema for structured output
firecrawl agent "Get company information" --urls https://example.com --schema '{"type":"object","properties":{"name":{"type":"string"},"founded":{"type":"number"}}}' --wait

# Use schema from a file
firecrawl agent "Get product details" --urls https://example.com --schema-file schema.json --wait
```

<div id="agent-options">
  #### Opciones del agente
</div>

```bash CLI theme={null}
# Spark 2 es el predeterminado: todas las ejecuciones se realizan con él
firecrawl agent "Competitive analysis across multiple domains" --model spark-2 --wait

# Obsoleto: los nombres de modelo de Spark 1 aún se aceptan, pero se redirigen a spark-2.

# Set max credits to limit costs
firecrawl agent "Gather contact information from company websites" --max-credits 100 --wait

# Check status of an existing job
firecrawl agent <job-id> --status

# Enviar eventos del agente a un webhook
firecrawl agent "Extract product details" --urls https://example.com --webhook '{"url":"https://example.com/webhook","events":["completed","failed"]}'

# Cancelar un trabajo de agente activo
firecrawl agent <job-id> --cancel

# Custom polling interval and timeout
firecrawl agent "Summarize recent blog posts" --wait --poll-interval 10 --timeout 300

# Save output to file
firecrawl agent "Find pricing information" --urls https://example.com --wait -o pricing.json --pretty
```

**Opciones disponibles:**

| Opción | Descripción |
| - | - |
| `--urls <urls>` | Lista opcional de URL en las que enfocar el agente (separadas por comas) |
| `--model <model>` | Modelo que se utilizará. El valor predeterminado es `spark-2`, el modelo con el que se ejecutan todas las ejecuciones. Los modelos Spark 1 están obsoletos y se redirigen a `spark-2` |
| `--schema <json>` | Esquema JSON para salida estructurada (cadena JSON en línea) |
| `--schema-file <path>` | Ruta al archivo de esquema JSON para salida estructurada |
| `--max-credits <number>` | Créditos máximos que se pueden gastar (el trabajo falla si se alcanza el límite) |
| `--webhook <url-or-json>` | URL o configuración del webhook |
| `--status` | Consultar el estado de un trabajo de agente existente |
| `--cancel` | Cancelar un trabajo de agente activo mediante el ID de trabajo |
| `--wait` | Esperar a que el agente termine antes de devolver los resultados |
| `--poll-interval <seconds>` | Intervalo de sondeo mientras se espera (predeterminado: 5) |
| `--timeout <seconds>` | Tiempo máximo de espera (predeterminado: sin límite) |
| `--output <path>` | Guardar la salida en un archivo |
| `--json` | Salida en formato JSON |

***

<div id="credit-usage">
  ### Uso de créditos
</div>

Consulta el saldo y el uso de créditos de tu equipo.

```bash CLI theme={null}
# View credit usage
firecrawl credit-usage

# Salida en formato JSON
firecrawl credit-usage --json --pretty
```

***

<div id="version">
  ### Versión
</div>

Mostrar la versión de la CLI.

```bash CLI theme={null}
firecrawl version
# o
firecrawl --version
```

<div id="global-options">
  ## Opciones globales
</div>

Estas opciones están disponibles para todos los comandos:

| Opción | Abrev. | Descripción |
| - | - | - |
| `--status` | | Muestra la versión, el estado de autenticación, la concurrencia y los créditos |
| `--api-key <key>` | `-k` | Sobrescribe la clave de API almacenada para este comando |
| `--api-url <url>` | | Usa una URL de API personalizada (para entornos autogestionados/desarrollo local) |
| `--help` | `-h` | Muestra la ayuda para un comando |
| `--version` | `-V` | Muestra la versión de la CLI |

`init` también acepta `--skip-auth`, `--skip-install`, `--skip-skills` y `--agent <name>`. Consulta `firecrawl init --help`.

<div id="output-handling">
  ## Manejo de la salida
</div>

La CLI envía la salida a stdout de forma predeterminada, lo que facilita usarla en pipes o redirigirla:

```bash CLI theme={null}
# Canalizar markdown a otro comando
firecrawl https://example.com | head -50

# Redirigir a un archivo
firecrawl https://example.com > output.md

# Guardar JSON con formato legible
firecrawl https://example.com --format markdown,links --pretty -o data.json
```

<div id="format-behavior">
  ### Comportamiento de los formatos
</div>

* **Un solo formato**: Devuelve contenido sin procesar (texto markdown, HTML, etc.)
* **Varios formatos**: Devuelve JSON con todos los datos solicitados

```bash CLI theme={null}
# Salida de markdown sin procesar
firecrawl https://example.com --format markdown

# Salida JSON con múltiples formatos
firecrawl https://example.com --format markdown,links
```

<div id="examples">
  ## Ejemplos
</div>

<div id="quick-scrape">
  ### Scrape rápido
</div>

```bash CLI theme={null}
# Obtener contenido markdown de una URL (usar --only-main-content para una salida limpia)
firecrawl https://docs.firecrawl.dev --only-main-content

# Get HTML content
firecrawl https://example.com --html -o page.html
```

<div id="full-site-crawl">
  ### Rastreo completo del sitio web
</div>

```bash CLI theme={null}
# Rastrear un sitio de documentación con límites
firecrawl crawl https://docs.example.com --limit 50 --max-depth 2 --wait --progress -o docs.json
```

<div id="site-discovery">
  ### Descubrimiento de sitios web
</div>

```bash CLI theme={null}
# Buscar todas las publicaciones del blog
firecrawl map https://example.com --search "blog" -o blog-urls.txt
```

<div id="research-workflow">
  ### Flujo de trabajo de investigación
</div>

```bash CLI theme={null}
# Buscar y extraer resultados para investigación
firecrawl search "machine learning best practices 2024" --scrape --scrape-formats markdown --pretty
```

<div id="agent-2">
  ### Agente
</div>

```bash CLI theme={null}
# URLs are optional
firecrawl agent "Encuentra las 5 principales startups de IA y sus montos de financiación" --wait

# Focus on specific URLs
firecrawl agent "Compare pricing plans" --urls https://slack.com/pricing,https://teams.microsoft.com/pricing --wait
```

<div id="combine-with-other-tools">
  ### Combínalo con otras herramientas
</div>

```bash CLI theme={null}
# Extract URLs from search results
jq -r '.data.web[].url' search-results.json

# Obtener títulos de resultados de búsqueda
jq -r '.data.web[] | "\(.title): \(.url)"' search-results.json

# Extraer enlaces como JSON e imprimir una URL por línea
firecrawl https://example.com --format links --json | jq -r '.links[]'

# Count URLs from map
firecrawl map https://example.com | wc -l
```

<div id="telemetry">
  ## Telemetría
</div>

La CLI recopila datos de uso anónimos durante la autenticación para ayudar a mejorar el producto:

* Versión de la CLI, sistema operativo y versión de Node.js
* Detección de herramientas de desarrollo (por ejemplo, Cursor, VS Code, Claude Code)

**No se recopilan datos de comandos, URL ni contenido de archivos a través de la CLI.**

Para desactivar la telemetría, configura la siguiente variable de entorno:

```bash CLI theme={null}
export FIRECRAWL_NO_TELEMETRY=1
```

<div id="open-source">
  ## Código abierto
</div>

La CLI de Firecrawl y los tres segmentos de skills son de código abierto en GitHub:

* [`firecrawl/cli`](https://github.com/firecrawl/cli) — la CLI y las skills de CLI (trabajo web en vivo)
* [`firecrawl/skills`](https://github.com/firecrawl/skills) — skills de Build (integrar Firecrawl en el código de la aplicación)
* [`firecrawl/firecrawl-workflows`](https://github.com/firecrawl/firecrawl-workflows) — skills de flujo de trabajo (entregables repetibles, como informes de investigación, auditorías SEO, listas de leads y clones de diseño)

> ¿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.
