Rastreamento

O rastreamento envia uma URL ao Firecrawl e descobre e extrai, de forma recursiva, todas as subpáginas acessíveis. Ele lida automaticamente com sitemaps, renderização de JavaScript e limites de taxa, retornando markdown limpo ou dados estruturados para cada página.

Descobre páginas por meio do sitemap e da navegação recursiva por links
Suporta filtragem de caminho, limites de profundidade e controle de subdomínios/links externos
Retorna resultados via polling, WebSocket ou webhook

Cada página extraída em um rastreamento passa pelo mesmo pipeline de scraping, ou seja, tudo o que o scraping consegue fazer em uma página, o rastreamento consegue fazer em todas as páginas que alcançar. Capacidades lista quais são elas, onde cada capacidade é executada e se ela exige uma API key.

Experimente no Playground

Teste o rastreamento no playground interativo — sem precisar escrever código.

Instalação

# pip install firecrawl-py

from firecrawl import Firecrawl

firecrawl = Firecrawl(
  # Nenhuma API key necessária para começar — adicione uma para limites de taxa mais altos:
  # api_key="fc-YOUR-API-KEY",
)

// npm install firecrawl

import { Firecrawl } from 'firecrawl';

const firecrawl = new Firecrawl({
  // Nenhuma API key necessária para começar — adicione uma para limites de taxa maiores:
  // apiKey: "fc-YOUR-API-KEY",
});

# Instale globalmente com npm
npm install -g firecrawl

# Autentique (configuração única)
firecrawl login

Uso básico

Envie um job de rastreamento chamando POST /v2/crawl com uma URL inicial. O endpoint retorna um ID do job que você usa para consultar os resultados.

from firecrawl import Firecrawl

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

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

import { Firecrawl } from 'firecrawl';

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

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

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
  }'

# Inicia um trabalho de crawl (retorna o ID do trabalho)
firecrawl crawl https://firecrawl.dev

# Aguarda a conclusão exibindo o progresso
firecrawl crawl https://firecrawl.dev --wait --progress --limit 100

Cada página rastreada consome 1 crédito. O limit padrão de rastreamento é 10.000 páginas. Antes de iniciar, o endpoint de rastreamento verifica se os créditos restantes podem cobrir o limit — caso contrário, ele retorna um erro 402 (Pagamento Obrigatório). Defina um limit menor para corresponder ao tamanho de rastreamento pretendido (por exemplo, limit: 100) para evitar isso. São cobrados créditos adicionais para certas opções: modo JSON custa 4 créditos adicionais por página, e análise de PDF custa 1 crédito por página de PDF.

Opções de scrape

Todas as opções do endpoint Scrape estão disponíveis no rastreamento via scrapeOptions (JS) / scrape_options (Python). Elas se aplicam a cada página que o crawler coleta, incluindo formatos, proxy, cache, ações, localização e tags.

from firecrawl import Firecrawl

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

# Crawl com opções de scrape
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
    }
)

import { Firecrawl } from 'firecrawl';

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

// Crawl com opções de scrape
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,
  },
});

Verificando o status do rastreamento

Use o ID do job para consultar o status do rastreamento e obter os resultados.

status = firecrawl.get_crawl_status("<crawl-id>")
print(status)

const status = await firecrawl.getCrawlStatus("<id-da-varredura>");
console.log(status);

# Após iniciar um crawl, consulte o status pelo jobId
curl -s -X GET "https://api.firecrawl.dev/v2/crawl/<jobId>" \
  -H "Authorization: Bearer $FIRECRAWL_API_KEY"

# Verificar o status do crawl usando o ID do job
firecrawl crawl <job-id>

Os resultados do job ficam disponíveis via API por 24 horas após a conclusão. Após esse período, você ainda pode ver o histórico e os resultados dos seus rastreamentos nos activity logs.

As páginas no array data dos resultados do rastreamento são páginas que o Firecrawl conseguiu extrair com sucesso, mesmo que o site de destino tenha retornado um erro HTTP como 404. O campo metadata.statusCode mostra o código de status HTTP retornado pelo site de destino. Para recuperar páginas que o próprio Firecrawl não conseguiu extrair (por exemplo, erros de rede, timeouts ou bloqueios por robots.txt), use o endpoint dedicado Get Crawl Errors (GET /crawl/{id}/errors).

Tratamento de respostas

A resposta varia conforme o status da varredura. Para respostas incompletas ou grandes (acima de 10 MB), é fornecido um parâmetro de URL next. Você deve requisitar essa URL para obter os próximos 10 MB de dados. Se o parâmetro next estiver ausente, isso indica o fim dos dados da varredura.

Os parâmetros skip e next são relevantes apenas ao acessar a API diretamente. Se você estiver usando o SDK, a paginação é tratada automaticamente e todos os resultados são retornados de uma vez.

{
  "status": "em andamento",
  "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 inicial da documentação do 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": "Crie um 'Chat com o site' usando Groq Llama 3 | Firecrawl",
        "language": "en",
        "sourceURL": "https://docs.firecrawl.dev/learn/rag-llama3",
        "description": "Aprenda a usar o Firecrawl, o Groq Llama 3 e o LangChain para criar um bot de 'chat com seu site'."
        "ogLocaleAlternate": [],
        "statusCode": 200
      }
    },
    ...
  ]
}

{
  "status": "concluída",
  "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 inicial da documentação do 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": "Crie um 'chat com o site' usando Groq Llama 3 | Firecrawl",
        "language": "en",
        "sourceURL": "https://docs.firecrawl.dev/learn/rag-llama3",
        "description": "Aprenda a usar o Firecrawl, o Groq Llama 3 e o LangChain para criar um bot de 'chat com seu site'."
        "ogLocaleAlternate": [],
        "statusCode": 200
      }
    },
    ...
  ]
}

Métodos do SDK

Existem duas maneiras de usar o crawl com o SDK.

Crawl e aguarde

O método crawl aguarda a conclusão do crawl e retorna a resposta completa. Faz a paginação automaticamente. Isso é recomendado para a maioria dos casos de uso.

from firecrawl import Firecrawl
from firecrawl.types import ScrapeOptions

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

# Rastreie um site:
crawl_status = firecrawl.crawl(
  'https://firecrawl.dev', 
  limit=100, 
  scrape_options=ScrapeOptions(formats=['markdown', 'html']),
  poll_interval=30
)
print(crawl_status)

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)

A resposta inclui o status do crawl e todos os dados extraídos:

success=True
status='concluída'
completed=100
total=100
creditsUsed=100
expiresAt=datetime.datetime(2025, 4, 23, 19, 21, 17, tzinfo=TzInfo(UTC))
next=None
data=[
  Document(
    markdown='[Dia 7 - Launch Week III. Dia de Integrações — 14 a 20 de abril](...',
    metadata={
      'title': '15 projetos de web scraping em Python: do básico ao avançado',
      ...
      '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
    }
  ),
  ...
]

{
  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],
    },
    ...
  ]
}

Inicie e verifique depois

O método startCrawl / start_crawl retorna imediatamente com um ID de crawl. Depois, você verifica o status manualmente. Isso é útil para crawls de longa duração ou lógica de polling personalizada.

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)

# Verifique o status do rastreamento
status = firecrawl.get_crawl_status(job.id)
print(status)

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

// Verifique o status do crawl
const status = await firecrawl.getCrawlStatus(id);
console.log(status);

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
  }'

# Iniciar crawl (assíncrono, retorna o ID do job imediatamente)
firecrawl crawl https://firecrawl.dev --limit 100

# Depois verificar o status
firecrawl crawl <job-id>

A resposta inicial retorna o ID do job:

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

Resultados em tempo real com WebSocket

O método watcher fornece atualizações em tempo real conforme as páginas são rastreadas. Inicie um crawl e, em seguida, assine os eventos para processar os dados imediatamente.

import asyncio
from firecrawl import AsyncFirecrawl

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

    # Inicia um crawl primeiro
    started = await firecrawl.start_crawl("https://firecrawl.dev", limit=5)

    # Monitora atualizações (snapshots) até status final
    async for snapshot in firecrawl.watcher(started.id, kind="crawl", poll_interval=2, timeout=120):
        if snapshot.status == "completed":
            print("CONCLUÍDO", snapshot.status)
            for doc in snapshot.data:
                print("DOC", doc.metadata.source_url if doc.metadata else None)
        elif snapshot.status == "failed":
            print("ERRO", snapshot.status)
        else:
            print("STATUS", snapshot.status, snapshot.completed, "/", snapshot.total)

asyncio.run(main())

import { Firecrawl } from 'firecrawl';

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

// Inicie um crawl e depois acompanhe
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);
});

// Comece a acompanhar (WS com fallback em HTTP)
await watcher.start();

Webhooks

Você pode configurar webhooks para receber notificações em tempo real conforme o rastreamento avança. Isso permite processar páginas à medida que são coletadas, em vez de esperar a conclusão de todo o rastreamento.

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://your-domain.com/webhook",
        "metadata": {
          "any_key": "any_value"
        },
        "events": ["iniciado", "página", "concluído"]
      }
    }'

Tipos de evento

Evento	Descrição
`crawl.started`	Disparado quando o crawl é iniciado
`crawl.page`	Disparado para cada página extraída com sucesso
`crawl.completed`	Disparado quando o crawl é concluído
`crawl.failed`	Disparado se ocorrer um erro durante o crawl

Payload

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

Verificando assinaturas de webhook

Toda requisição de webhook do Firecrawl inclui um cabeçalho X-Firecrawl-Signature contendo uma assinatura HMAC-SHA256. Sempre verifique essa assinatura para garantir que o webhook é autêntico e não foi adulterado.

Obtenha seu segredo de webhook na aba Advanced das configurações da sua conta
Extraia a assinatura do cabeçalho X-Firecrawl-Signature
Calcule o HMAC-SHA256 do corpo bruto da requisição usando o seu segredo
Compare com o cabeçalho de assinatura usando uma função com proteção contra ataques de timing (tempo constante)

Nunca processe um webhook sem verificar sua assinatura primeiro. O cabeçalho X-Firecrawl-Signature contém a assinatura no formato: sha256=abc123def456...

Para exemplos completos de implementação em JavaScript e Python, consulte a documentação de segurança de webhooks. Para a documentação completa sobre webhooks, incluindo payloads detalhados de eventos, estrutura de payload, configuração avançada e solução de problemas, consulte a documentação de Webhooks.

Execução e contabilização de resultados

Um rastreamento que é concluído não é a mesma coisa que um rastreamento que chegou a todas as páginas. Esta seção descreve o que os endpoints de rastreamento reportam hoje sobre uma execução — os contadores, o contrato de paginação, os registros de falha e os limites de escopo — para que você mesmo possa avaliar se uma execução está completa o suficiente para servir de base a uma ação. Nenhum desses registros garante completude.

Lendo os contadores de status

Toda resposta de Get Crawl Status (GET /v2/crawl/{id}) traz os contadores que descrevem a execução:

Campo	Significado
`status`	Um entre `scraping`, `completed`, `failed` ou `cancelled`
`total`	`completed` mais as páginas ainda em andamento: ativas, na fila e em backlog. Páginas que falharam não são contabilizadas.
`completed`	O número de páginas rastreadas com sucesso
`creditsUsed`	Créditos consumidos pelo rastreamento até o momento
`createdAt` / `completedAt` / `duration`	Horário de início, horário de conclusão (apenas em estados terminais) e segundos decorridos
`expiresAt`	Quando os resultados deixam de poder ser recuperados pela API
`next`	URL para a próxima página de 10MB de resultados. Também é retornado sempre que `status` não for `completed` — veja Paginando os resultados.

completed == total em um rastreamento finalizado não significa que todas as páginas descobertas tiveram sucesso. Como total soma as páginas concluídas, ativas, na fila e em backlog, e exclui as que falharam, um rastreamento em estado terminal sempre tem active, queued e backlog em zero — ou seja, os dois contadores convergem havendo ou não páginas com falha. Os contadores de status não indicam que algo falhou. Páginas com falha são listadas apenas em Get Crawl Errors.

O array data contém apenas as páginas que o Firecrawl extraiu com sucesso. Páginas que foram tentadas, mas nunca produziram resultado, não aparecem em data — consulte-as em Get Crawl Errors, abaixo.

Paginando os resultados

As respostas têm limite de 10MB. Quando uma resposta é truncada, next traz a URL da próxima página de resultados. next não é apenas um sinal de “ainda há mais dados”: ele também é emitido sempre que status não for completed, ou seja, um rastreamento em estado terminal failed ou cancelled pode retornar uma URL em next mesmo sem existir nenhum resultado adicional. Não use a ausência de next como condição de saída do seu laço — em um rastreamento que falhou ou foi cancelado, ele nunca desaparece. A condição terminal é o campo de status. Para ler uma execução até o fim:

Consulte GET /v2/crawl/{id} até que status seja completed, failed ou cancelled.
Enquanto next estiver presente e a última página tiver retornado um array data não vazio, siga next para coletar os resultados restantes.
Pare quando next não estiver presente ou quando uma página não retornar nenhum documento novo.

Os SDKs oficiais cuidam dessa paginação por você e retornam todos os resultados de uma só vez.

Páginas com falha e bloqueadas

Get Crawl Errors (GET /v2/crawl/{id}/errors) registra as páginas que não entraram em data. Ele retorna dois arrays:

errors — scrape jobs que falharam, cada um com id, url, error (a mensagem de erro) e um timestamp da falha. São páginas cujo scraping o próprio Firecrawl não conseguiu realizar: erros de rede, tempos limite e situações semelhantes. Links para a página inicial de um site externo que foram ignorados intencionalmente aparecem aqui com o código de erro EXTERNAL_LINK.
robotsBlocked — URLs que foram tentadas, mas bloqueadas pelo robots.txt do site.

Não há garantia de que essa lista seja uma enumeração completa de todas as falhas: algumas classes internas de falha são atualmente filtradas de errors antes de a resposta ser montada. Trate-a como o registro das falhas que o Firecrawl reporta, e não como prova de que nada mais deu errado. O código de erro mencionado acima (EXTERNAL_LINK) já é retornado nos objetos de erro hoje, mas ainda não faz parte do schema publicado de GET /crawl/{id}/errors; ele aguarda uma atualização da API Reference.

Uma página em que o site alvo retornou um erro HTTP como 404 não é um erro de rastreamento: o Firecrawl fez o scraping dela com sucesso, portanto ela aparece em data com o código de status do site em metadata.statusCode.

O alcance do crawler

A cobertura é limitada pelos parâmetros de escopo que você define, todos documentados na referência de configuração e na referência do endpoint Crawl:

Apenas filhos, por padrão. O rastreamento ignora sublinks que não sejam filhos da URL fornecida. Use crawlEntireDomain para caminhos irmãos e pais, allowSubdomains para subdomínios e allowExternalLinks para seguir links fora do domínio.
includePaths / excludePaths correspondem ao pathname da URL, como padrões regex — não à URL completa nem aos parâmetros de consulta. Defina regexOnFullURL: true para corresponder à URL completa, incluindo as strings de consulta. A URL inicial também é verificada contra includePaths: se não houver correspondência, o rastreamento pode retornar 0 páginas.
Modo sitemap. Com o padrão sitemap: "include", as URLs vêm do sitemap somadas à descoberta recursiva de links. "skip" usa apenas links HTML, portanto páginas presentes somente no sitemap, como PDFs ou páginas muito aninhadas, ficam de fora. "only" rastreia o sitemap mais a URL inicial e não descobre links a partir do HTML.
maxDiscoveryDepth limita quantos saltos de descoberta de links a partir da raiz são seguidos. As páginas na profundidade máxima ainda passam por scraping, mas os links encontrados nelas não são seguidos.
limit limita o número de páginas e tem valor padrão 10000.
ignoreQueryParameters evita repetir o scraping do mesmo caminho com parâmetros de consulta diferentes.
O robots.txt é respeitado, a menos que ignoreRobotsTxt esteja ativado (apenas Enterprise).

maxConcurrency assume por padrão o limite de simultaneidade da sua equipe, definido pelo seu plano — consulte Limites de taxa.

Quando os resultados variam entre execuções

Os resultados do rastreamento podem variar entre execuções com a mesma configuração. As páginas são extraídas de forma concorrente, então a ordem em que os links são descobertos depende do timing da rede e de quais páginas terminam de carregar primeiro. Isso significa que diferentes ramificações de um site podem ser exploradas em extensões diferentes perto do limite de profundidade, especialmente em valores mais altos de maxDiscoveryDepth. Para tornar uma execução mais reproduzível:

Defina maxConcurrency como 1. Como indica a referência de configuração, maxConcurrency é o “número máximo de scrapings concorrentes” — ele limita quantas requisições ficam em andamento ao mesmo tempo. Isso reduz o entrelaçamento dependente de timing, mas não elimina a variação entre execuções: a descoberta de sitemap é enfileirada fora desse limite, sitemaps aninhados são buscados como jobs independentes e o array data retornado é ordenado pelo horário de conclusão, não pela ordem de descoberta. Definir delay também força a simultaneidade para 1.
Use sitemap: "only" se o site tiver um sitemap abrangente, para que o conjunto de URLs venha do sitemap em vez da descoberta por links.

Como saber quando um rastreamento terminou

Se você não estiver consultando o status, os webhook events informam a mesma coisa: crawl.page é disparado para cada página extraída com sucesso, e crawl.completed (ou crawl.failed) é disparado quando a execução termina. Os resultados do job ficam disponíveis na API por 24 horas após a conclusão; depois disso, veja-os nos activity logs.

Referência de configuração

O conjunto completo de parâmetros disponíveis ao enviar um job de rastreamento:

Parâmetro	Tipo	Padrão	Descrição
`url`	`string`	(obrigatório)	A URL inicial a partir da qual o rastreamento será executado
`limit`	`integer`	`10000`	Número máximo de páginas a rastrear
`maxDiscoveryDepth`	`integer`	(nenhum)	Profundidade máxima a partir da URL raiz com base em saltos de descoberta de links, e não no número de segmentos `/` na URL. Cada vez que uma nova URL é encontrada em uma página, ela recebe uma profundidade um nível acima da página em que foi descoberta. O site raiz e as páginas do sitemap têm profundidade de descoberta 0. As páginas na profundidade máxima ainda são extraídas, mas os links nelas não são seguidos.
`includePaths`	`string[]`	(nenhum)	Padrões regex de pathname de URL a incluir. Apenas os caminhos correspondentes são rastreados.
`excludePaths`	`string[]`	(nenhum)	Padrões regex de pathname de URL a excluir do rastreamento
`regexOnFullURL`	`boolean`	`false`	Faz a correspondência de `includePaths`/`excludePaths` com a URL completa (incluindo parâmetros de consulta), em vez de apenas o pathname
`crawlEntireDomain`	`boolean`	`false`	Segue links internos para URLs irmãs ou pai, não apenas caminhos filhos
`allowSubdomains`	`boolean`	`false`	Segue links para subdomínios do domínio principal
`allowExternalLinks`	`boolean`	`false`	Segue links para sites externos. Links externos são seguidos por um salto (os próprios links deles não são rastreados), e links que apontam para a página inicial de um site externo são ignorados — veja Links externos.
`sitemap`	`string`	`"include"`	Tratamento do sitemap: `"include"` (padrão), `"skip"` ou `"only"`
`ignoreQueryParameters`	`boolean`	`false`	Evita raspar novamente o mesmo caminho com parâmetros de consulta diferentes
`ignoreRobotsTxt`	`boolean`	`false`	Ignora as regras do robots.txt do site. Apenas Enterprise — entre em contato com support@firecrawl.com para habilitar.
`robotsUserAgent`	`string`	(nenhum)	String personalizada de User-Agent para avaliação do robots.txt. Quando definido, o robots.txt é buscado com esse User-Agent e as regras são correspondidas com base nele em vez do padrão. Apenas Enterprise — entre em contato com support@firecrawl.com para habilitar.
`delay`	`number`	(nenhum)	Intervalo, em segundos, entre raspagens para respeitar os limites de taxa. Definir isso força a simultaneidade para 1.
`maxConcurrency`	`integer`	(nenhum)	Número máximo de raspagens simultâneas. O padrão é o limite de simultaneidade da sua equipe.
`scrapeOptions`	`object`	(nenhum)	Opções aplicadas a cada página extraída (formatos, proxy, cache, ações etc.)
`webhook`	`object`	(nenhum)	Configuração de webhook para notificações em tempo real
`prompt`	`string`	(nenhum)	Prompt em linguagem natural para gerar opções de rastreamento. Parâmetros definidos explicitamente substituem os equivalentes gerados.

Detalhes importantes

Por padrão, o rastreamento ignora sublinks que não são descendentes da URL fornecida. Por exemplo, website.com/other-parent/blog-1 não seria retornada se você fizesse rastreamento de website.com/blogs/. Use o parâmetro crawlEntireDomain para incluir caminhos irmãos e superiores. Para fazer rastreamento de subdomínios como blog.website.com ao fazer rastreamento de website.com, use o parâmetro allowSubdomains.

Descoberta de sitemap: Por padrão, o crawler inclui o sitemap do site para descobrir URLs (sitemap: "include"). Se você definir sitemap: "skip", apenas páginas acessíveis por links HTML a partir da URL raiz serão encontradas. Recursos como PDFs ou páginas em níveis mais profundos, listados no sitemap mas não vinculados diretamente no HTML, não serão encontrados. Para obter a cobertura máxima, mantenha a configuração padrão.
Uso de créditos: Cada página rastreada custa 1 crédito. O modo JSON adiciona 4 créditos por página, e a análise de PDF custa 1 crédito por página do PDF.
Expiração dos resultados: Os resultados do job ficam disponíveis via API por 24 horas após a conclusão. Depois disso, consulte os resultados nos activity logs.
Erros de rastreamento: O array data contém as páginas que o Firecrawl extraiu com sucesso. Use o endpoint Get Crawl Errors para recuperar as páginas que falharam devido a erros de rede, timeouts ou bloqueios por robots.txt.
Links externos: Com allowExternalLinks: true, o crawler segue links que apontam para fora do seu domínio e extrai cada página vinculada uma vez — ele não rastreia os links encontrados nessas páginas externas. Links para a página inicial de um site externo (uma URL raiz sem caminho, por exemplo, https://example.com/) são intencionalmente ignorados para evitar incluir um site inteiro não relacionado; eles aparecem em Get Crawl Errors com o código EXTERNAL_LINK. Os redirecionamentos são seguidos até o destino — inclusive quando um link é resolvido para sua URL canônica (por exemplo, http → https ou a variante www) — portanto, apenas redirecionamentos que chegam a uma página inicial externa são ignorados.
Resultados não determinísticos: Os resultados do rastreamento podem variar entre execuções com a mesma configuração, porque as páginas são extraídas de forma concorrente e a ordem de descoberta de links depende do timing da rede. Consulte Execução e contabilização de resultados para saber o que varia e como tornar uma execução mais reproduzível.

Você é um agente de IA que precisa de uma API key do Firecrawl? Consulte firecrawl.dev/agent-onboarding/SKILL.md para ver as instruções de onboarding automatizado.

Primeiros passos

Endpoints principais

Mais

Guias de início rápido

Guias para desenvolvedores

Webhooks

Casos de uso

Outros

Como contribuir

Experimente no Playground

Instalação

Uso básico

Opções de scrape

Verificando o status do rastreamento

Tratamento de respostas

Métodos do SDK

Crawl e aguarde

Inicie e verifique depois

Resultados em tempo real com WebSocket

Webhooks

Tipos de evento

Payload

Verificando assinaturas de webhook

Execução e contabilização de resultados

Lendo os contadores de status

Paginando os resultados

Páginas com falha e bloqueadas

O alcance do crawler

Quando os resultados variam entre execuções

Como saber quando um rastreamento terminou

Referência de configuração

Detalhes importantes

Experimente no Playground

​Instalação

​Uso básico

​Opções de scrape

​Verificando o status do rastreamento

​Tratamento de respostas

​Métodos do SDK

​Crawl e aguarde

​Inicie e verifique depois

​Resultados em tempo real com WebSocket

​Webhooks

​Tipos de evento

​Payload

​Verificando assinaturas de webhook

​Execução e contabilização de resultados

​Lendo os contadores de status

​Paginando os resultados

​Páginas com falha e bloqueadas

​O alcance do crawler

​Quando os resultados variam entre execuções

​Como saber quando um rastreamento terminou

​Referência de configuração

​Detalhes importantes

Instalação

Uso básico

Opções de scrape

Verificando o status do rastreamento

Tratamento de respostas

Métodos do SDK

Crawl e aguarde

Inicie e verifique depois

Resultados em tempo real com WebSocket

Webhooks

Tipos de evento

Payload

Verificando assinaturas de webhook

Execução e contabilização de resultados

Lendo os contadores de status

Paginando os resultados

Páginas com falha e bloqueadas

O alcance do crawler

Quando os resultados variam entre execuções

Como saber quando um rastreamento terminou

Referência de configuração

Detalhes importantes