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

# Skills + CLI

> As skills do Firecrawl são uma forma simples de agentes de IA, como Claude Code, Antigravity e OpenCode, usarem o Firecrawl via CLI.

Pesquise, faça scraping, interaja, rastreie, mapeie e execute jobs de agente diretamente do terminal. A CLI do Firecrawl funciona de forma independente ou com skills que agentes de IA para programação, como Claude Code, Antigravity e OpenCode, podem descobrir e usar automaticamente.

<div id="installation">
  ## Instalação
</div>

Se você estiver usando um agente de IA, como o Claude Code, poderá instalar as Firecrawl skills abaixo, e o agente as configurará para você.

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

* `--all` instala todos os segmentos de skills do Firecrawl (CLI, build, fluxos de trabalho) em todos os agentes de codificação de IA detectados
* `--browser` abre o navegador automaticamente para autenticação do Firecrawl

<Note>
  Após instalar as skills, reinicie seu agente para que ele as descubra.
</Note>

Você também pode instalar manualmente a CLI do Firecrawl globalmente usando npm:

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

<div id="authentication">
  ## Autenticação
</div>

Antes de usar a CLI, você precisa se autenticar com sua chave de API do Firecrawl.

<Note>
  **Alguns comandos da CLI funcionam sem login.** Sem uma chave de API configurada, os comandos compatíveis recorrem ao plano gratuito sem chave — grátis, mas com limite de taxa por IP. Consulte [Limites de taxa](/pt-BR/rate-limits#keyless-no-api-key) para ver a lista atual de comandos sem chave e as ressalvas. [Cadastre-se para obter uma chave gratuita](https://firecrawl.dev) e ganhar 1.000 créditos e limites mais altos; a CLI a usa automaticamente assim que ela é configurada.
</Note>

<div id="login">
  ### Login
</div>

```bash CLI theme={null}
# Login interativo (abre o navegador ou solicita a chave da API)
firecrawl login

# Login com autenticação do navegador (recomendado para agentes)
firecrawl login --browser

# Login com chave da API diretamente
firecrawl login --api-key fc-YOUR-API-KEY

# Ou defina via variável de ambiente
export FIRECRAWL_API_KEY=fc-YOUR-API-KEY
```

<div id="view-configuration">
  ### Visualizar configuração
</div>

```bash CLI theme={null}
# Ver configuração atual e status de autenticação
firecrawl view-config
```

<div id="logout">
  ### Logout
</div>

```bash CLI theme={null}
# Limpar credenciais armazenadas
firecrawl logout
```

<div id="self-hosted-local-development">
  ### Auto-hospedado / Desenvolvimento local
</div>

Para instâncias auto-hospedadas do Firecrawl ou para desenvolvimento local, use a opção `--api-url`:

```bash CLI theme={null}
# Use uma instância local do Firecrawl (nenhuma chave de API necessária)
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
```

Ao usar uma URL de API personalizada (qualquer endereço diferente de `https://api.firecrawl.dev`), a autenticação por chave de API é automaticamente ignorada, permitindo que você use instâncias locais sem uma chave de API.

<div id="check-status">
  ### Verificar status
</div>

Verifique se a instalação e a autenticação estão corretas e consulte os limites de taxa:

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

Resultado quando estiver pronto:

```
  🔥 firecrawl cli v1.16.2

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

* **Concorrência**: Máximo de tarefas em paralelo. Execute operações paralelas próximas a esse limite, mas sem ultrapassá-lo.
* **Créditos**: Créditos de API disponíveis. Cada operação de scrape/crawl consome créditos.

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

<Note>
  O comando oculto `firecrawl browser` foi descontinuado para fluxos de trabalho com agentes. Use primeiro `firecrawl scrape <url>` e depois `firecrawl interact ...` com a sessão de scraping resultante.
</Note>

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

Faça scraping de uma única URL e extraia seu conteúdo em vários formatos.

<Tip>
  Use `--only-main-content` para obter um resultado limpo, sem navegação, rodapés ou anúncios. Isso é recomendado para a maioria dos casos de uso em que você quer apenas o artigo ou o conteúdo principal da página.
</Tip>

```bash CLI theme={null}
# Faz scrape de uma URL (padrão: saída em markdown)
firecrawl https://example.com

# Ou use o comando explícito de scrape
firecrawl scrape https://example.com

# Recomendado: use --only-main-content para saída limpa sem navegação/rodapé
firecrawl https://example.com --only-main-content
```

<div id="output-formats">
  #### Formatos de saída
</div>

```bash CLI theme={null}
# Obter saída HTML
firecrawl https://example.com --html

# Múltiplos formatos (retorna JSON)
firecrawl https://example.com --format markdown,links

# Obter imagens de uma página
firecrawl https://example.com --format images

# Obter um resumo do conteúdo da página
firecrawl https://example.com --format summary

# Rastrear alterações em uma página
firecrawl https://example.com --format changeTracking

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

<div id="scrape-options">
  #### Opções de scraping
</div>

```bash CLI theme={null}
# Extrai apenas o conteúdo principal (remove navegação e rodapés)
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

# Extrai JSON estruturado com um schema
firecrawl https://example.com --format json --schema '{"type":"object","properties":{"title":{"type":"string"}}}'

# Executa ações de scraping leves antes da extração
firecrawl https://example.com --actions '[{"type":"wait","milliseconds":1000}]'

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

# Oculta informações de identificação pessoal
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
```

**Opções disponíveis:**

| Opção                    | Atalho | Descrição                                                                                                                                                                    |
| ------------------------ | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--url <url>`            | `-u`   | URL para extrair conteúdo (alternativa ao argumento posicional)                                                                                                              |
| `--format <formats>`     | `-f`   | formatos de saída (separados por vírgula): `markdown`, `html`, `rawHtml`, `links`, `screenshot`, `json`, `images`, `summary`, `rastreioDeMudanças`, `attributes`, `branding` |
| `--html`                 | `-H`   | Atalho para `--format html`                                                                                                                                                  |
| `--only-main-content`    |        | Extrair apenas o conteúdo principal                                                                                                                                          |
| `--wait-for <ms>`        |        | Tempo de espera, em milissegundos, para renderização de JS                                                                                                                   |
| `--screenshot`           |        | Fazer uma captura de tela                                                                                                                                                    |
| `--full-page-screenshot` |        | Fazer uma captura de tela da página inteira                                                                                                                                  |
| `--include-tags <tags>`  |        | Tags HTML a incluir (separadas por vírgula)                                                                                                                                  |
| `--exclude-tags <tags>`  |        | Tags HTML a excluir (separadas por vírgula)                                                                                                                                  |
| `--schema <json>`        |        | schema JSON para extração estruturada                                                                                                                                        |
| `--schema-file <path>`   |        | Caminho para o arquivo de schema JSON                                                                                                                                        |
| `--actions <json>`       |        | Array JSON de ações a serem executadas durante o scraping                                                                                                                    |
| `--actions-file <path>`  |        | Caminho para o arquivo JSON de ações                                                                                                                                         |
| `--proxy <proxy>`        |        | Modo de proxy para scraping (por exemplo, `auto` ou `basic`)                                                                                                                 |
| `--redact-pii`           |        | Ocultar informações de identificação pessoal do conteúdo retornado                                                                                                           |
| `--output <path>`        | `-o`   | Salvar o resultado em um arquivo                                                                                                                                             |
| `--json`                 |        | Forçar saída em JSON mesmo com um único formato                                                                                                                              |
| `--pretty`               |        | Imprimir a saída JSON formatada                                                                                                                                              |
| `--timing`               |        | Mostrar tempo da requisição e outras informações úteis                                                                                                                       |

***

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

Pesquise na web e, opcionalmente, faça o scraping dos resultados.

```bash CLI theme={null}
# Pesquisar na web
firecrawl search "web scraping tutorials"

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

# Imprimir resultados formatados
firecrawl search "machine learning" --pretty
```

<div id="search-options">
  #### Opções de busca
</div>

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

# Buscar com filtros de categoria
firecrawl search "react hooks" --categories github
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   # Last week
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
```

**Opções disponíveis:**

| Opção                        | Descrição                                                                                      |
| ---------------------------- | ---------------------------------------------------------------------------------------------- |
| `--limit <number>`           | Número máximo de resultados (padrão: 5, máx.: 100)                                             |
| `--sources <sources>`        | Fontes de pesquisa: `web`, `images`, `news` (separadas por vírgula)                            |
| `--categories <categories>`  | Filtrar por categoria: `github`, `research`, `pdf` (separadas por vírgula)                     |
| `--tbs <value>`              | Filtro de tempo: `qdr:h` (hora), `qdr:d` (dia), `qdr:w` (semana), `qdr:m` (mês), `qdr:y` (ano) |
| `--location <location>`      | Segmentação geográfica (ex.: "Berlin,Germany")                                                 |
| `--country <code>`           | Código de país ISO (padrão: US)                                                                |
| `--timeout <ms>`             | Tempo limite em milissegundos (padrão: 60000)                                                  |
| `--ignore-invalid-urls`      | Excluir URLs inválidas para outros endpoints do Firecrawl                                      |
| `--scrape`                   | Fazer scraping dos resultados da pesquisa                                                      |
| `--scrape-formats <formats>` | Formatos para o conteúdo extraído (padrão: markdown)                                           |
| `--only-main-content`        | Incluir apenas o conteúdo principal ao fazer scraping (padrão: true)                           |
| `--json`                     | Saída em JSON                                                                                  |
| `--output <path>`            | Salvar saída em arquivo                                                                        |
| `--pretty`                   | Imprimir saída JSON formatada                                                                  |

***

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

Descubra rapidamente todas as URLs de um site.

```bash CLI theme={null}
# Descobre todas as URLs de um site
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">
  #### Opções para mapear
</div>

```bash CLI theme={null}
# Filtrar URLs por consulta de pesquisa
firecrawl map https://example.com --search "blog"

# Incluir subdomínios
firecrawl map https://example.com --include-subdomains

# Controlar uso do sitemap
firecrawl map https://example.com --sitemap include   # Usar sitemap
firecrawl map https://example.com --sitemap skip      # Pular sitemap
firecrawl map https://example.com --sitemap only      # Usar apenas sitemap

# Ignorar parâmetros de consulta (dedupe URLs)
firecrawl map https://example.com --ignore-query-parameters

# Aguardar conclusão do mapeamento com timeout
firecrawl map https://example.com --wait --timeout 60

# Salvar em arquivo
firecrawl map https://example.com -o urls.txt
firecrawl map https://example.com --json --pretty -o urls.json
```

**Opções disponíveis:**

| Opção                       | Descrição                                               |
| --------------------------- | ------------------------------------------------------- |
| `--url <url>`               | URL a ser mapeada (alternativa ao argumento posicional) |
| `--limit <number>`          | Número máximo de URLs a serem descobertas               |
| `--search <query>`          | Filtra URLs pela consulta de busca                      |
| `--sitemap <mode>`          | Tratamento de sitemap: `include`, `skip`, `only`        |
| `--include-subdomains`      | Inclui subdomínios                                      |
| `--ignore-query-parameters` | Trata URLs com parâmetros diferentes como iguais        |
| `--wait`                    | Aguarda o término do mapeamento                         |
| `--timeout <seconds>`       | Tempo limite, em segundos                               |
| `--json`                    | Saída em JSON                                           |
| `--output <path>`           | Salva a saída em um arquivo                             |
| `--pretty`                  | Imprime a saída JSON formatada                          |

***

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

Faça scraping de uma página e, em seguida, interaja com ela usando linguagem natural ou código. O Interact usa o scraping mais recente por padrão, ou você pode informar um ID de scraping específico.

```bash CLI theme={null}
# 1. Faça scraping da página inicial da Amazon (o ID de scraping é salvo automaticamente)
firecrawl scrape https://www.amazon.com

# 2. Interaja — busque um produto e obtenha seu preço
firecrawl interact "Search for iPhone 16 Pro Max"
firecrawl interact "Click on the first result and tell me the price"

# 3. Encerre a sessão
firecrawl interact stop
```

**Opções disponíveis:**

| Option                 | Description                                        |
| ---------------------- | -------------------------------------------------- |
| `-p, --prompt <text>`  | Prompt de IA (alternativa ao argumento posicional) |
| `-c, --code <code>`    | Código para executar na sessão ativa da página     |
| `-s, --scrape-id <id>` | ID do job de scraping (padrão: último scraping)    |
| `--python`             | Executar código como Python/Playwright             |
| `--node`               | Executar código como Node.js/Playwright (padrão)   |
| `--bash`               | Executar código como Bash                          |
| `--timeout <seconds>`  | Tempo limite em segundos (1–300, padrão: 30)       |
| `--output <path>`      | Salvar o resultado em um arquivo                   |
| `--json`               | Resultado em formato JSON                          |

***

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

Rastreia um site inteiro a partir de uma URL.

```bash CLI theme={null}
# Inicia um crawl (retorna o ID do job imediatamente)
firecrawl crawl https://example.com

# Aguarda a conclusão do crawl
firecrawl crawl https://example.com --wait

# Aguarda com indicador de progresso
firecrawl crawl https://example.com --wait --progress
```

<div id="check-crawl-status">
  #### Verificar status do crawl
</div>

```bash CLI theme={null}
# Verificar o status do crawl usando o ID do job
firecrawl crawl <job-id>

# Exemplo com um ID de job real
firecrawl crawl 550e8400-e29b-41d4-a716-446655440000
```

<div id="crawl-options">
  #### Opções de Crawl
</div>

```bash CLI theme={null}
# Limitar profundidade e páginas do rastreamento
firecrawl crawl https://example.com --limit 100 --max-depth 3 --wait

# Incluir apenas caminhos específicos
firecrawl crawl https://example.com --include-paths /blog,/docs --wait

# Excluir caminhos específicos
firecrawl crawl https://example.com --exclude-paths /admin,/login --wait

# Incluir subdomínios
firecrawl crawl https://example.com --allow-subdomains --wait

# Rastrear domínio inteiro
firecrawl crawl https://example.com --crawl-entire-domain --wait

# Limitação de taxa
firecrawl crawl https://example.com --delay 1000 --max-concurrency 2 --wait

# Passar opções de scraping para cada página rastreada
firecrawl crawl https://example.com --scrape-options '{"formats":["markdown"],"onlyMainContent":true}'

# Enviar eventos de conclusão de rastreamento para um webhook
firecrawl crawl https://example.com --webhook '{"url":"https://example.com/webhook","events":["completed"]}'

# Cancelar um rastreamento ativo
firecrawl crawl <job-id> --cancel

# Intervalo de polling e timeout personalizados
firecrawl crawl https://example.com --wait --poll-interval 10 --timeout 300

# Salvar resultados em arquivo
firecrawl crawl https://example.com --wait --pretty -o results.json
```

**Opções disponíveis:**

| Opção                          | Descrição                                               |
| ------------------------------ | ------------------------------------------------------- |
| `--url <url>`                  | URL para rastrear (alternativa ao argumento posicional) |
| `--wait`                       | Aguardar a conclusão do crawl                           |
| `--progress`                   | Mostrar indicador de progresso enquanto aguarda         |
| `--poll-interval <seconds>`    | Intervalo de consulta (polling) (padrão: 5)             |
| `--timeout <seconds>`          | Tempo limite ao aguardar                                |
| `--status`                     | Verificar o status de uma tarefa de crawl existente     |
| `--limit <number>`             | Número máximo de páginas a rastrear                     |
| `--max-depth <number>`         | Profundidade máxima do crawl                            |
| `--include-paths <paths>`      | Caminhos a incluir (separados por vírgula)              |
| `--exclude-paths <paths>`      | Caminhos a excluir (separados por vírgula)              |
| `--sitemap <mode>`             | Tratamento de sitemap: `include`, `skip`, `only`        |
| `--allow-subdomains`           | Incluir subdomínios                                     |
| `--allow-external-links`       | Seguir links externos                                   |
| `--crawl-entire-domain`        | Rastrear o domínio inteiro                              |
| `--ignore-query-parameters`    | Tratar URLs com parâmetros diferentes como iguais       |
| `--delay <ms>`                 | Atraso entre requisições                                |
| `--max-concurrency <n>`        | Máximo de requisições concorrentes                      |
| `--scrape-options <json>`      | Opções de scraping em JSON passadas para cada página    |
| `--scrape-options-file <path>` | Caminho para o arquivo JSON de opções de scraping       |
| `--webhook <url-or-json>`      | URL ou configuração de Webhook                          |
| `--cancel`                     | Cancelar uma tarefa de crawl ativa pelo ID do job       |
| `--output <path>`              | Salvar resultado em arquivo                             |
| `--pretty`                     | Imprimir saída JSON formatada                           |

***

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

Crie operações recorrentes de scraping ou rastreamento que comparem cada execução ao snapshot anterior. Adicione um objetivo quando quiser que o Firecrawl avalie quais páginas alteradas são relevantes para o seu 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>
```

Os objetivos do monitor devem ser curtos e fiéis à intenção do usuário: diga o que deve acionar um alerta, retome qualquer escopo informado e inclua exclusões apenas quando forem óbvias ou explicitamente solicitadas. Se o usuário pedir "any change", mantenha o objetivo amplo.

**Opções disponíveis:**

| Opção                     | Descrição                                                                    |
| ------------------------- | ---------------------------------------------------------------------------- |
| `--name <name>`           | Nome do monitor                                                              |
| `--goal <goal>`           | Objetivo para avaliar mudanças relevantes                                    |
| `--cron <expression>`     | Agendamento cron, por exemplo `*/30 * * * *`                                 |
| `--schedule <text>`       | Agendamento em linguagem natural, por exemplo `hourly`                       |
| `--timezone <tz>`         | Fuso horário do agendamento, padrão `UTC`                                    |
| `--page <url>`            | URL de uma única página para fazer scraping a cada verificação               |
| `--scrape-urls <list>`    | URLs de páginas separadas por vírgula para fazer scraping a cada verificação |
| `--crawl-url <url>`       | URL raiz de um alvo de rastreamento                                          |
| `--webhook-url <url>`     | Destino do Webhook                                                           |
| `--webhook-events <list>` | Eventos do monitor separados por vírgula                                     |
| `--email <list>`          | Destinatários de email separados por vírgula                                 |
| `--retention-days <n>`    | Janela de retenção de snapshots                                              |
| `--page-status <state>`   | Filtrar páginas em `monitor check`                                           |
| `--state <state>`         | Definir o estado do monitor em `monitor update`: active/paused               |

***

### Agent

Busque e colete dados na web usando prompts em linguagem natural.

```bash CLI theme={null}
# Uso básico - URLs são opcionais
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">
  #### Opções do Agente
</div>

```bash CLI theme={null}
# Use Spark 1 Pro for higher accuracy
firecrawl agent "Competitive analysis across multiple domains" --model spark-1-pro --wait

# 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 do agente para um webhook
firecrawl agent "Extract product details" --urls https://example.com --webhook '{"url":"https://example.com/webhook","events":["completed","failed"]}'

# Cancelar um job de agente ativo
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
```

**Opções disponíveis:**

| Option                      | Description                                                                                    |
| --------------------------- | ---------------------------------------------------------------------------------------------- |
| `--urls <urls>`             | Lista opcional de URLs nas quais o agente deve focar (separadas por vírgula)                   |
| `--model <model>`           | Modelo a ser usado: `spark-1-mini` (padrão, 60% mais barato) ou `spark-1-pro` (maior precisão) |
| `--schema <json>`           | schema JSON para saída estruturada (string JSON inline)                                        |
| `--schema-file <path>`      | Caminho para o arquivo de schema JSON para saída estruturada                                   |
| `--max-credits <number>`    | Máximo de créditos a consumir (a tarefa falha se o limite for atingido)                        |
| `--webhook <url-or-json>`   | URL do Webhook ou configuração                                                                 |
| `--status`                  | Verificar o status de uma tarefa de agente existente                                           |
| `--cancel`                  | Cancelar um job de agente ativo pelo ID do job                                                 |
| `--wait`                    | Aguardar o agente concluir antes de retornar os resultados                                     |
| `--poll-interval <seconds>` | Intervalo de polling enquanto aguarda (padrão: 5)                                              |
| `--timeout <seconds>`       | Tempo limite (timeout) enquanto aguarda (padrão: sem limite)                                   |
| `--output <path>`           | Salvar a saída em arquivo                                                                      |
| `--json`                    | Saída em formato JSON                                                                          |

***

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

Verifique o saldo de créditos e o uso pela sua equipe.

```bash CLI theme={null}
# Ver uso de créditos
firecrawl credit-usage

# Saída em JSON
firecrawl credit-usage --json --pretty
```

***

<div id="version">
  ### Versão
</div>

Exibe a versão da CLI.

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

<div id="global-options">
  ## Opções globais
</div>

Essas opções estão disponíveis para todos os comandos:

| Opção             | Atalho | Descrição                                                                  |
| ----------------- | ------ | -------------------------------------------------------------------------- |
| `--status`        |        | Exibe a versão, autenticação, concorrência e créditos                      |
| `--api-key <key>` | `-k`   | Substitui a chave de API armazenada para este comando                      |
| `--api-url <url>` |        | Usa uma URL de API personalizada (para self-hosting/desenvolvimento local) |
| `--help`          | `-h`   | Exibe a ajuda de um comando                                                |
| `--version`       | `-V`   | Exibe a versão da CLI                                                      |

<div id="output-handling">
  ## Manipulação da saída
</div>

A CLI envia a saída para stdout por padrão, facilitando o uso de pipes ou redirecionamentos:

```bash CLI theme={null}
# Pipe markdown para outro comando
firecrawl https://example.com | head -50

# Redirecionar para um arquivo
firecrawl https://example.com > output.md

# Salvar JSON com formatação legível
firecrawl https://example.com --format markdown,links --pretty -o data.json
```

<div id="format-behavior">
  ### Comportamento dos formatos
</div>

* **Formato único**: Retorna o conteúdo bruto (texto markdown, HTML, etc.)
* **Múltiplos formatos**: Retorna um JSON com todos os dados solicitados

```bash CLI theme={null}
# Raw markdown output
firecrawl https://example.com --format markdown

# Saída JSON com múltiplos formatos
firecrawl https://example.com --format markdown,links
```

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

<div id="quick-scrape">
  ### Raspagem rápida
</div>

```bash CLI theme={null}
# Obter conteúdo markdown de uma URL (use --only-main-content para saída limpa)
firecrawl https://docs.firecrawl.dev --only-main-content

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

<div id="full-site-crawl">
  ### Rastreamento completo do site
</div>

```bash CLI theme={null}
# Rastreia um site de docs com limites
firecrawl crawl https://docs.example.com --limit 50 --max-depth 2 --wait --progress -o docs.json
```

<div id="site-discovery">
  ### Descoberta de sites
</div>

```bash CLI theme={null}
# Encontre todas as postagens do blog
firecrawl map https://example.com --search "blog" -o blog-urls.txt
```

<div id="research-workflow">
  ### Fluxo de Pesquisa
</div>

```bash CLI theme={null}
# Buscar e raspar resultados para pesquisa
firecrawl search "machine learning best practices 2024" --scrape --scrape-formats markdown --pretty
```

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

```bash CLI theme={null}
# URLs are optional
firecrawl agent "Encontre as 5 principais startups de IA e seus valores de financiamento" --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">
  ### Combine com outras ferramentas
</div>

```bash CLI theme={null}
# Extrair URLs dos resultados de pesquisa
jq -r '.data.web[].url' search-results.json

# Get titles from search results
jq -r '.data.web[] | "\(.title): \(.url)"' search-results.json

# Extract links and process with jq
firecrawl https://example.com --format links | jq '.links[].url'

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

<div id="telemetry">
  ## Telemetria
</div>

A CLI coleta dados de uso anônimos durante a autenticação para ajudar a melhorar o produto:

* Versão da CLI, sistema operacional e versão do Node.js
* Detecção de ferramenta de desenvolvimento (como Cursor, VS Code, Claude Code)

**Nenhum dado relacionado a comandos, URLs ou conteúdo de arquivos é coletado via CLI.**

Para desativar a telemetria, defina a seguinte variável de ambiente:

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

<div id="open-source">
  ## Open Source
</div>

A CLI do Firecrawl e os três segmentos de skills são de código aberto no GitHub:

* [`firecrawl/cli`](https://github.com/firecrawl/cli) — a CLI e as skills de CLI (trabalho na web em tempo real)
* [`firecrawl/skills`](https://github.com/firecrawl/skills) — build skills (integre o Firecrawl ao código da aplicação)
* [`firecrawl/firecrawl-workflows`](https://github.com/firecrawl/firecrawl-workflows) — skills de fluxo de trabalho (entregáveis repetíveis, como briefs de pesquisa, auditorias de SEO, listas de leads e clones de design)

> Você é um agente de IA que precisa de uma chave de API do Firecrawl? Consulte [firecrawl.dev/agent-onboarding/SKILL.md](https://www.firecrawl.dev/agent-onboarding/SKILL.md) para ver instruções de integração automatizada.