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

# Desenvolva com IA

> Tudo o que você precisa para conectar seu agente de IA ao Firecrawl.

Se você está desenvolvendo com IA, a Firecrawl oferece vários recursos para melhorar sua experiência. A Firecrawl inclui **skills** — pacotes de conhecimento autocontidos que agentes de codificação com IA descobrem e usam automaticamente. Com um único comando de instalação, os agentes recebem três conjuntos completos de skills: skills de CLI para trabalhar com a web em tempo real, skills de build para integrar a Firecrawl ao código da aplicação e skills de fluxo de trabalho para gerar entregas repetíveis. Usuários do Firecrawl podem obter uma API key de duas maneiras. Veja [Obter credenciais](#get-credentials) abaixo.

* [Obter credenciais](#get-credentials)
* [Skills + CLI](#skills-cli)
* [Usando o Firecrawl como ferramenta](#using-firecrawl-as-a-tool)
* [Depuração agêntica](#agentic-debugging)
* [servidor MCP do Firecrawl](#firecrawl-mcp-server)
* [Documentação do Firecrawl para agentes](#firecrawl-docs-for-agents)
* [Guias de início rápido](#quick-start-guides)
* [Integrações com agentes](#agent-harnesses)
* [SDKs](#sdks)

<div id="get-credentials">
  ## Obter credenciais
</div>

Os usuários do Firecrawl podem obter uma chave de API de duas formas. A maioria deve fazer login pelo painel ou pela CLI. Se a sua plataforma de agente for compatível com WorkOS ID-JAG, ela poderá se registrar diretamente no Firecrawl.

**Qual devo usar?** Use o painel ou a CLI, a menos que você saiba que sua plataforma é compatível com WorkOS ID-JAG.

**Como você pode ter chegado aqui:**

* **Docs:** você chegou a esta página. Escolha a opção abaixo que corresponde à forma como você pode fazer login.
* **API `401`:** agentes compatíveis com ID-JAG podem seguir o fluxo de descoberta na Etapa 1 de [`auth.md`](https://www.firecrawl.dev/auth.md). Todos os demais devem usar o painel ou a CLI.
* **URL direta:** siga [`SKILL.md`](https://www.firecrawl.dev/agent-onboarding/SKILL.md) para fazer login pelo navegador e configurar tudo, ou [`auth.md`](https://www.firecrawl.dev/auth.md) para registro com WorkOS ID-JAG.

<CardGroup cols={2}>
  <Card title="Use o painel ou a CLI" icon="user" href="https://www.firecrawl.dev/agent-onboarding/SKILL.md">
    **Padrão para a maioria dos usuários.** Faça login no navegador, execute a CLI com `--browser`, instale skills e MCP ou crie uma chave de API no painel.
  </Card>

  <Card title="Registre-se com WorkOS ID-JAG" icon="robot" href="/pt-BR/ai-onboarding/agent-auth">
    **Para plataformas de agente compatíveis.** Use esta opção quando sua plataforma puder emitir um WorkOS ID-JAG para o Firecrawl. Consulte [Agent Auth](/pt-BR/ai-onboarding/agent-auth) e depois siga [`auth.md`](https://www.firecrawl.dev/auth.md).
  </Card>
</CardGroup>

**Não consegue fazer login nem obter uma chave?** Quando seu agente não consegue obter uma chave de API e o humano não consegue se cadastrar, você ainda pode usar o tier Free sem chave para fazer busca, scraping e interagir sem uma chave de API. Ele tem limite de taxa e serve como alternativa de contingência, então migre para uma conta Free ou uma chave de API assim que alguma dessas opções estiver disponível. Consulte [Keyless (no API key)](/pt-BR/rate-limits#keyless-no-api-key) para mais detalhes.

Depois de obter uma chave de API, continue com [Skills + CLI](#skills-cli) abaixo.

<div id="skills-cli">
  ## Skills + CLI
</div>

A [CLI do Firecrawl](/pt-BR/sdks/cli) permite que seu agente faça busca, scraping, interaja, faça rastreamento, mapeamento, extração e execute jobs de agente pelo terminal. Ela foi criada para humanos, agentes de IA e pipelines de CI/CD.

As **skills** do Firecrawl são pacotes de conhecimento autocontidos que agentes de programação com IA, como Claude Code, Antigravity e OpenCode, descobrem e usam automaticamente. Um único comando de instalação configura tudo — as ferramentas de CLI para trabalho web em tempo real, as skills de build para integrar o Firecrawl ao código da aplicação e as skills de fluxo de trabalho para produzir entregas repetíveis:

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

* `--all` instala cada segmento de skills do Firecrawl (CLI, build, fluxos de trabalho) em todos os agentes de programação com IA detectados na máquina
* `--browser` abre o navegador automaticamente para autenticação no Firecrawl

Após a instalação, verifique se tudo está funcionando:

```bash theme={null}
firecrawl --status
firecrawl scrape "https://firecrawl.dev"
```

Para reinstalar ou direcionar a um agente específico mais tarde:

```bash theme={null}
firecrawl setup skills      # CLI + skills de build
firecrawl setup workflows   # skills de fluxo de trabalho
```

<div id="what-the-install-gives-you">
  ### O que a instalação oferece
</div>

A instalação configura três categorias de skills que cobrem todas as formas de um agente usar o Firecrawl. Cada segmento fica em seu próprio repositório para poder evoluir de forma independente:

* [`firecrawl/cli`](https://github.com/firecrawl/cli) — skills de CLI para trabalho na web em tempo real
* [`firecrawl/skills`](https://github.com/firecrawl/skills) — skills de build para integração com aplicações
* [`firecrawl/firecrawl-workflows`](https://github.com/firecrawl/firecrawl-workflows) — skills de fluxo de trabalho para entregáveis repetíveis

**Skills de CLI** — para trabalho na web em tempo real durante uma sessão do agente:

| Skill                | Purpose                                                  |
| -------------------- | -------------------------------------------------------- |
| `firecrawl/cli`      | Fluxo geral de comandos da CLI                           |
| `firecrawl-search`   | Fazer uma busca na web e descobrir páginas               |
| `firecrawl-scrape`   | Extrair conteúdo limpo de uma URL conhecida              |
| `firecrawl-interact` | Interagir com páginas extraídas usando prompts ou código |
| `firecrawl-crawl`    | Extrair conteúdo em massa de um site inteiro             |
| `firecrawl-map`      | Descobrir todas as URLs de um domínio                    |
| `firecrawl-agent`    | Executar coleta autônoma de dados da web com um job      |

**Skills de build** — para integrar o Firecrawl ao código da aplicação:

| Skill                        | Purpose                                                   |
| ---------------------------- | --------------------------------------------------------- |
| `firecrawl-build`            | Escolher o endpoint certo do Firecrawl para o seu produto |
| `firecrawl-build-onboarding` | Autenticação e configuração do projeto                    |
| `firecrawl-build-scrape`     | Implementar scraping no código da aplicação               |
| `firecrawl-build-search`     | Implementar busca no código da aplicação                  |
| `firecrawl-build-interact`   | Implementar interação com a página no código da aplicação |
| `firecrawl-build-crawl`      | Implementar rastreamento no código da aplicação           |
| `firecrawl-build-map`        | Implementar descoberta de URLs no código da aplicação     |
| `firecrawl-build-parse`      | Implementar análise de documentos no código da aplicação  |

**Skills de fluxo de trabalho** — skills focadas em resultados que produzem um entregável concreto a partir de dados da web do Firecrawl:

| Skill                            | Outcome                                                                                                     |
| -------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| `firecrawl-workflows`            | Skill principal para escolher o fluxo de trabalho certo                                                     |
| `firecrawl-deep-research`        | Relatórios de pesquisa com múltiplas fontes                                                                 |
| `firecrawl-seo-audit`            | Mapas do site, verificações de SEO on-page, comparação de SERP e correções priorizadas                      |
| `firecrawl-lead-research`        | Briefings de inteligência sobre empresas e pessoas antes de reuniões                                        |
| `firecrawl-lead-gen`             | Geração de listas de prospects a partir de bancos de dados e diretórios                                     |
| `firecrawl-qa`                   | Relatórios de QA de sites em produção com problemas e etapas de reprodução                                  |
| `firecrawl-competitive-intel`    | Monitoramento recorrente de pricing, recursos e changelog                                                   |
| `firecrawl-market-research`      | Pesquisa de mercado, financeira, de resultados e de setor                                                   |
| `firecrawl-research-papers`      | Revisões de literatura a partir de papers, PDFs e whitepapers                                               |
| `firecrawl-company-directories`  | Extração de diretórios para listas estruturadas de empresas                                                 |
| `firecrawl-dashboard-reporting`  | Extração de métricas de painéis e ferramentas web internas                                                  |
| `firecrawl-knowledge-base`       | Documentação de referência pronta para LLM, chunks de RAG, dados de treinamento ou espelhos da documentação |
| `firecrawl-knowledge-ingest`     | Ingestão de portais de documentação protegidos por autenticação ou com uso intenso de JS                    |
| `firecrawl-demo-walkthrough`     | Guias passo a passo de fluxos de produto e relatórios de análise de UX                                      |
| `firecrawl-shop`                 | Pesquisa de produtos e recomendações de compra                                                              |
| `firecrawl-website-design-clone` | Extrair o sistema de design de um website para um `DESIGN.md` pronto para agentes                           |

<div id="choose-your-path">
  ### Escolha seu caminho
</div>

Todas as três categorias de skill usam a mesma instalação. A diferença está no que acontece depois:

<Steps>
  <Step title="Ferramentas web em tempo real (skills de CLI)">
    Use esta opção quando precisar de dados da web na sessão atual — para buscar na web, fazer scraping de URLs conhecidas, interagir com páginas extraídas, fazer rastreamento de documentação, mapear um site ou executar um job de agente.

    O fluxo padrão:

    1. Comece com **busca** quando precisar descobrir conteúdo
    2. Vá para **scraping** quando já tiver uma URL
    3. Use **interagir** quando a página extraída precisar de ações complementares
    4. Use **map** ou **rastreamento** quando precisar de muitas URLs ou páginas
    5. Use **agent** quando a tarefa for aberta e exigir descoberta autônoma

    ```bash theme={null}
    # Fazer uma busca na web
    firecrawl search "best open-source web crawlers"

    # Fazer scraping de uma página em markdown limpo
    firecrawl scrape https://docs.firecrawl.dev

    # Fazer crawl de um site inteiro
    firecrawl crawl https://docs.firecrawl.dev
    ```
  </Step>

  <Step title="Integração com aplicação (skills de Build)">
    Use esta opção quando estiver criando uma aplicação, agente ou fluxo de trabalho que chama a API do Firecrawl via código. As skills de build ajudam a escolher o endpoint certo, configurar o SDK e executar um smoke test.

    O agente responde a uma pergunta central — *o que o Firecrawl deve fazer no produto?* — e as skills de build encaminham para `/search`, `/scrape`, `/interact`, `/parse`, `/crawl`, `/map` ou `/agent`, conforme o caso.
  </Step>

  <Step title="Entregas repetíveis (skills de fluxo de trabalho)">
    Use esta opção quando o objetivo for um artefato finalizado — um relatório de pesquisa, auditoria de SEO, relatório de QA, lista de leads, base de conhecimento, resumo de inteligência competitiva ou um sistema de design clonado — e não dados brutos da web ou código de produto.

    As skills de fluxo de trabalho inferem primeiro com base no contexto e só fazem perguntas curtas de esclarecimento quando uma entrada bloquearia o trabalho. Elas também destacam unidades que podem ser paralelizadas de forma independente para que subagentes possam se distribuir entre concorrentes, páginas ou fontes.

    Escolha um workflow diretamente ou deixe a skill abrangente `firecrawl-workflows` encaminhar a solicitação:

    ```bash theme={null}
    # Resumo de pesquisa com múltiplas fontes sobre um tema
    "Use firecrawl-deep-research to write a brief on AI agent frameworks"

    # Inteligência pré-reunião para uma chamada de vendas
    "Use firecrawl-lead-research to brief me on stripe.com before my 3pm call"

    # Auditoria de SEO on-page com correções priorizadas
    "Use firecrawl-seo-audit on https://example.com"

    # Clonar o sistema de design de um site em DESIGN.md
    "Use firecrawl-website-design-clone on https://linear.app"
    ```
  </Step>

  <Step title="API REST (sem necessidade de instalação)">
    Se preferir não instalar nada, agentes podem chamar a API REST do Firecrawl diretamente. Defina a chave de API e chame os endpoints:

    * `POST https://api.firecrawl.dev/v2/search` — descobre páginas por consulta
    * `POST https://api.firecrawl.dev/v2/scrape` — extrai markdown limpo de uma URL
    * `POST https://api.firecrawl.dev/v2/scrape/{scrapeId}/interact` — interage com uma página extraída
    * `POST https://api.firecrawl.dev/v2/crawl` — extrai em lote um site inteiro
    * `POST https://api.firecrawl.dev/v2/map` — descobre URLs em um domínio
    * `POST https://api.firecrawl.dev/v2/agent` — executa coleta autônoma de dados da web

    Cabeçalho de autenticação: `Authorization: Bearer fc-YOUR_API_KEY`
  </Step>
</Steps>

As definições completas de onboarding estão disponíveis em:

* Login no navegador, configuração da CLI, skills, MCP e chaves do painel: [`firecrawl.dev/agent-onboarding/SKILL.md`](https://www.firecrawl.dev/agent-onboarding/SKILL.md)
* Registro de agente com WorkOS ID-JAG: [`firecrawl.dev/auth.md`](https://www.firecrawl.dev/auth.md)

Agentes podem acessar qualquer um dos documentos diretamente: use [`agent-onboarding/SKILL.md`](https://www.firecrawl.dev/agent-onboarding/SKILL.md) para onboarding de CLI/navegador com humano no circuito, ou [`auth.md`](https://www.firecrawl.dev/auth.md) para registro no WorkOS ID-JAG.

<CardGroup cols={3}>
  <Card title="skills de CLI" icon="terminal" href="https://github.com/firecrawl/cli">
    Trabalho web em tempo real durante uma sessão de agente — busca, scraping, interact, map, rastreamento e execução de jobs de agente pelo terminal.
  </Card>

  <Card title="skills de build" icon="code" href="https://github.com/firecrawl/skills">
    Integre o Firecrawl ao código da aplicação — escolha o endpoint certo, configure o SDK e entregue uma integração validada.
  </Card>

  <Card title="skills de fluxo de trabalho" icon="diagram-project" href="https://github.com/firecrawl/firecrawl-workflows">
    Produza entregas repetíveis — resumos de pesquisa, auditorias de SEO, relatórios de QA, listas de leads, bases de conhecimento e clones de design.
  </Card>
</CardGroup>

<div id="using-firecrawl-as-a-tool">
  ## Usando o Firecrawl como ferramenta
</div>

O Firecrawl oferece aos agentes cinco ferramentas principais para trabalhar com a web. Cada ferramenta corresponde a um endpoint da API e a um comando na CLI. Os agentes escolhem a ferramenta certa com base no que precisam:

<AccordionGroup>
  <Accordion title="Search — descubra páginas por consulta" icon="magnifying-glass">
    Comece por aqui quando você ainda não tiver uma URL. A busca retorna páginas relevantes da web para uma consulta em linguagem natural, com a opção de incluir o conteúdo completo da página nos resultados.

    ```bash theme={null}
    # CLI
    firecrawl search "latest OpenAI API pricing"
    ```

    ```bash theme={null}
    # API REST
    curl -X POST https://api.firecrawl.dev/v2/search \
      -H "Authorization: Bearer fc-YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"query": "latest OpenAI API pricing"}'
    ```

    **Quando usar:** Tarefas de pesquisa, busca de documentação, análise competitiva, resposta a perguntas que exigem informações atualizadas da web.
  </Accordion>

  <Accordion title="Scraping — extraia conteúdo de uma URL" icon="file-lines">
    Use-o quando você já tiver uma URL e precisar de conteúdo limpo, pronto para LLM. O Scraping converte qualquer página da web em markdown, HTML ou dados estruturados — lidando automaticamente com renderização de JavaScript, medidas anti-bot e HTML desorganizado.

    ```bash theme={null}
    # CLI
    firecrawl scrape https://docs.stripe.com/api/charges
    ```

    ```bash theme={null}
    # API REST
    curl -X POST https://api.firecrawl.dev/v2/scrape \
      -H "Authorization: Bearer fc-YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"url": "https://docs.stripe.com/api/charges"}'
    ```

    **Quando usar:** Leitura de documentação, extração de conteúdo de artigos, coleta de dados de uma página conhecida, conversão de páginas da web em contexto para LLMs.
  </Accordion>

  <Accordion title="Rastreamento — extraia em massa um site inteiro" icon="spider">
    O Rastreamento segue links recursivamente a partir de uma URL inicial e faz scraping de todas as páginas que encontra. Use-o quando você precisar de conteúdo de um site inteiro ou de um conjunto de documentação, e não apenas de uma única página.

    ```bash theme={null}
    # CLI
    firecrawl crawl https://docs.firecrawl.dev --limit 50
    ```

    ```bash theme={null}
    # API REST
    curl -X POST https://api.firecrawl.dev/v2/crawl \
      -H "Authorization: Bearer fc-YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"url": "https://docs.firecrawl.dev", "limit": 50}'
    ```

    **Quando usar:** Ingestão de sites completos de documentação, criação de bases de conhecimento, migração de conteúdo, coleta de dados de treinamento.
  </Accordion>

  <Accordion title="Map — descubra todas as URLs de um domínio" icon="sitemap">
    O Map descobre rapidamente todas as URLs indexadas em um domínio sem fazer scraping do conteúdo. Use-o quando você precisar entender a estrutura de um site ou encontrar páginas específicas antes de extrair o conteúdo delas.

    ```bash theme={null}
    # CLI
    firecrawl map https://docs.firecrawl.dev
    ```

    ```bash theme={null}
    # API REST
    curl -X POST https://api.firecrawl.dev/v2/map \
      -H "Authorization: Bearer fc-YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"url": "https://docs.firecrawl.dev"}'
    ```

    **Quando usar:** Auditorias de site, busca de páginas específicas em um site grande, entendimento da estrutura do site antes de um rastreamento direcionado.
  </Accordion>

  <Accordion title="Interagir — trabalhe com uma página extraída" icon="hand-pointer">
    O Interagir permite que os agentes continuem a partir de um scraping usando prompts ou código. Use-o quando uma página extraída exigir cliques, preenchimento de formulários, navegação ou extração complementar.

    ```bash theme={null}
    # CLI
    firecrawl scrape https://example.com
    firecrawl interact "Click the pricing tab and extract the plan names"
    ```

    ```bash theme={null}
    # API REST
    # scrapeId vem da resposta do scrape (data.metadata.scrapeId)
    curl -X POST https://api.firecrawl.dev/v2/scrape/SCRAPE_ID/interact \
      -H "Authorization: Bearer fc-YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"prompt": "Click the pricing tab and extract the plan names"}'
    ```

    **Quando usar:** Continuação a partir de um scraping, navegação em páginas dinâmicas, preenchimento de formulários e extração de dados após ações na página.
  </Accordion>
</AccordionGroup>

<div id="how-agents-chain-tools-together">
  ### Como os agentes encadeiam ferramentas
</div>

A maioria dos fluxos de trabalho de agentes combina várias ferramentas. Um padrão típico:

1. **Search** para encontrar páginas relevantes → obter uma lista de URLs
2. **Scrape** das URLs mais relevantes → obter conteúdo limpo
3. **Interact** quando a página extraída exigir ações de acompanhamento
4. **Agent** quando a tarefa exigir descoberta autônoma ou extração estruturada em várias páginas

Para tarefas em massa, os agentes usam **Map** primeiro para descobrir URLs e, depois, **Crawl** ou **Scrape** seletivamente as páginas de que precisam.

<div id="agentic-debugging">
  ## depuração agêntica
</div>

Quando uma chamada do Firecrawl falha ou retorna resultados inesperados, seu agente não precisa encaminhar o caso para um humano. O endpoint [`/support/ask`](/pt-BR/api-reference/endpoint/ask) é um agente de suporte com IA criado para comunicação **entre agentes** — ele diagnostica problemas com seus jobs, conta e uso da API e, em seguida, retorna uma resposta verificada com parâmetros de correção legíveis por máquina que seu agente pode aplicar diretamente.

Integre-o ao fluxo de tratamento de erros do seu agente para que ele possa se recuperar sozinho de falhas de scraping, problemas de rastreamento e erros de configuração — normalmente em 15–30 segundos, sem intervenção humana.

<div id="how-it-works">
  ### Como funciona
</div>

1. **Seu agente descreve o problema** — uma pergunta em linguagem natural que descreve o problema.
2. **O agente de suporte investiga** — ele inspeciona os logs do job, o estado da conta, a documentação e o código-fonte.
3. **O agente de suporte valida** — quando possível, ele testa uma correção na API Firecrawl em produção (por exemplo, refazendo um scraping com parâmetros ajustados).
4. **Seu agente recebe uma resposta verificada** — um `answer` em texto corrido, `fixParameters` legíveis por máquina para aplicar diretamente e resultados de `validation` mostrando se a correção foi testada.

<div id="example">
  ### Exemplo
</div>

Envie uma pergunta, além de um `rationale` opcional para dar contexto ao agente de suporte sobre o que seu usuário final está tentando fazer:

```bash theme={null}
curl -X POST https://api.firecrawl.dev/v2/support/ask \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "question": "my crawl returned 3 pages but I expected 50",
    "rationale": "user is on their third failed crawl attempt today"
  }'
```

A resposta inclui um `answer`, uma classificação de `confidence`, `fixParameters` opcionais (por exemplo, `{"waitFor": 5000}`) que seu agente pode passar na próxima chamada e `validation`, indicando se a correção foi testada na API real.

<Card title="Referência do endpoint Ask" icon="life-ring" href="/pt-BR/api-reference/endpoint/ask">
  Schema completo de requisição e resposta para `/support/ask`, incluindo códigos de status e o envelope de feedback retornado quando o agente não consegue prosseguir.
</Card>

<div id="firecrawl-mcp-server">
  ## servidor MCP do Firecrawl
</div>

MCP é um protocolo aberto que padroniza como os aplicativos fornecem contexto aos LLMs. Entre outros benefícios, ele oferece aos LLMs ferramentas para agir em seu nome. Nosso [servidor MCP](https://github.com/firecrawl/firecrawl-mcp-server) é de código aberto e abrange toda a nossa API — busca, scraping, interação, rastreamento, mapeamento, extração e agente.

Use a URL hospedada remotamente:

```
https://mcp.firecrawl.dev/{FIRECRAWL_API_KEY}/v2/mcp
```

Ou adicione o servidor local em qualquer cliente MCP:

```json theme={null}
{
  "mcpServers": {
    "firecrawl": {
      "command": "npx",
      "args": ["-y", "firecrawl-mcp"],
      "env": {
        "FIRECRAWL_API_KEY": "fc-YOUR-API-KEY"
      }
    }
  }
}
```

<Card title="servidor MCP" icon="plug" href="/pt-BR/mcp-server">
  Veja as instruções de instalação para Cursor, Claude Desktop, Windsurf, VS Code e outros.
</Card>

<div id="firecrawl-docs-for-agents">
  ## Documentação do Firecrawl para agentes
</div>

Você pode fornecer ao seu agente a documentação atual do Firecrawl de forma contextual. Os agentes podem começar a usar por conta própria ao buscar esses recursos diretamente — sem configuração manual por humanos.

<Steps>
  <Step title="Obter credenciais">
    Comece em [Obter credenciais](/pt-BR/ai-onboarding#get-credentials) para escolher entre a configuração pelo painel/CLI e o registro no WorkOS ID-JAG. Para o registro do ID-JAG, siga [`auth.md`](https://www.firecrawl.dev/auth.md).
  </Step>

  <Step title="Docs em markdown">
    Cada página tem uma versão em markdown. Adicione `.md` a qualquer URL da documentação ou use o menu de ações da página para copiar a página em markdown.

    ```
    Docs desta página: https://docs.firecrawl.dev/ai-onboarding.md
    ```
  </Step>

  <Step title="llms.txt completo">
    Forneça ao seu agente toda a nossa documentação em um único arquivo.

    ```
    Aqui estão os docs do Firecrawl: https://docs.firecrawl.dev/llms-full.txt
    ```

    Uma versão resumida do índice também está disponível em `https://docs.firecrawl.dev/llms.txt`.
  </Step>

  <Step title="Servidor de docs MCP">
    Para uma abordagem estruturada com ferramentas MCP, conecte o servidor MCP do Firecrawl em qualquer cliente MCP (Cursor, Claude Code, Claude Desktop, Windsurf). Consulte a página [servidor MCP](/pt-BR/mcp-server) para ver os comandos de instalação.
  </Step>

  <Step title="Copiar para ChatGPT / Claude">
    Cada página inclui um menu de ações contextual (copiar, visualizar em markdown, abrir no ChatGPT, abrir no Claude), para que agentes e humanos possam mover páginas entre ferramentas com um clique.
  </Step>
</Steps>

<div id="quick-start-guides">
  ## Guias de início rápido
</div>

Guias de início rápido prontos para uso para as stacks que os agentes mais usam. Aponte seu agente para qualquer um deles para gerar uma integração Firecrawl funcional de ponta a ponta.

Prefere deixar o Cursor fazer o trabalho? Instale o servidor MCP do Firecrawl com um clique e comece a enviar prompts no Cursor:

<a href="cursor://anysphere.cursor-deeplink/mcp/install?name=firecrawl&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsImZpcmVjcmF3bC1tY3AiXSwiZW52Ijp7IkZJUkVDUkFXTF9BUElfS0VZIjoiWU9VUi1BUEktS0VZIn19">
  <img src="https://cursor.com/deeplink/mcp-install-dark.png" alt="Abrir no Cursor — Adicionar servidor MCP do Firecrawl" style={{ maxHeight: 32 }} />
</a>

<CardGroup cols={3}>
  <Card title="Node.js" icon="node-js" href="/pt-BR/quickstarts/nodejs">
    JavaScript e TypeScript do lado do servidor com o SDK de Node do Firecrawl.
  </Card>

  <Card title="Next.js" icon="react" href="/pt-BR/quickstarts/nextjs">
    Faça scraping, busca e rastreamento com route handlers e server actions do Next.js.
  </Card>

  <Card title="Python" icon="python" href="/pt-BR/quickstarts/python">
    Use o Firecrawl em scripts, notebooks e serviços de backend.
  </Card>

  <Card title="FastAPI" icon="bolt" href="/pt-BR/quickstarts/fastapi">
    Crie APIs Python assíncronas para busca, scraping e extração.
  </Card>

  <Card title="Cloudflare Workers" icon="cloudflare" href="/pt-BR/quickstarts/cloudflare-workers">
    Execute o Firecrawl na edge com Workers.
  </Card>

  <Card title="Vercel Functions" icon="triangle" href="/pt-BR/quickstarts/vercel-functions">
    Chame o Firecrawl a partir de funções serverless da Vercel.
  </Card>

  <Card title="AWS Lambda" icon="aws" href="/pt-BR/quickstarts/aws-lambda">
    Invoque o Firecrawl a partir de handlers do Lambda.
  </Card>

  <Card title="Supabase Edge Functions" icon="database" href="/pt-BR/quickstarts/supabase-edge-functions">
    Use o Firecrawl no runtime Deno do Supabase.
  </Card>

  <Card title="Go" icon="golang" href="/pt-BR/quickstarts/go">
    SDK Go idiomático para busca, scraping e rastreamento.
  </Card>

  <Card title="Rust" icon="rust" href="/pt-BR/quickstarts/rust">
    SDK Rust tipado para Firecrawl.
  </Card>

  <Card title="Laravel" icon="laravel" href="/pt-BR/quickstarts/laravel">
    Adicione o Firecrawl a apps Laravel com o SDK PHP.
  </Card>

  <Card title="Rails" icon="gem" href="/pt-BR/quickstarts/rails">
    Use o Firecrawl no Ruby on Rails.
  </Card>
</CardGroup>

Veja a lista completa de guias de início rápido (Express, NestJS, Fastify, Hono, Bun, Remix, Nuxt, SvelteKit, Astro, Mastra, Django, Flask, Elixir, Java, Spring Boot, .NET, ASP.NET Core e mais) na barra lateral esquerda.

<div id="agent-harnesses">
  ## Integrações com agentes
</div>

O Firecrawl funciona com os runtimes e frameworks em que os agentes realmente rodam — agentes de código, SDKs de agentes e agregadores de modelos. A maioria desses ambientes de codificação consegue descobrir automaticamente as skills do Firecrawl via `npx -y firecrawl-cli@latest init --all --browser`; os demais usam o Firecrawl como ferramenta via MCP ou API REST.

<CardGroup cols={3}>
  <Card title="Claude Code" icon="terminal" href="/pt-BR/quickstarts/claude-code">
    CLI da Anthropic — configure o Firecrawl MCP no Claude Code.
  </Card>

  <Card title="Cursor" icon="arrow-pointer" href="/pt-BR/quickstarts/cursor">
    Agente para IDE — instale o Firecrawl MCP no Cursor com um clique.
  </Card>

  <Card title="OpenCode" icon="code-branch" href="/pt-BR/quickstarts/opencode">
    Conecte o Firecrawl MCP ao OpenCode.
  </Card>

  <Card title="Codex CLI" icon="code" href="/pt-BR/quickstarts/codex-cli">
    Conecte o Firecrawl MCP ao OpenAI Codex CLI.
  </Card>

  <Card title="OpenRouter" icon="route" href="/pt-BR/quickstarts/openrouter">
    Combine qualquer modelo do OpenRouter com as ferramentas web do Firecrawl.
  </Card>

  <Card title="Amp" icon="bolt" href="/pt-BR/quickstarts/amp">
    Conecte o Firecrawl MCP ao Sourcegraph Amp.
  </Card>

  <Card title="Windsurf" icon="wind" href="/pt-BR/quickstarts/windsurf">
    IDE com agentes — configure o Firecrawl MCP no Windsurf.
  </Card>

  <Card title="Antigravity" icon="rocket" href="/pt-BR/quickstarts/antigravity">
    Adicione o Firecrawl MCP à IDE com agentes do Google.
  </Card>

  <Card title="Gemini CLI" icon="gem" href="/pt-BR/quickstarts/gemini-cli">
    Conecte o Firecrawl MCP ao Google Gemini CLI.
  </Card>

  <Card title="Nous Research" icon="brain" href="/pt-BR/quickstarts/nous-research">
    Use o Firecrawl como ferramenta com modelos Hermes.
  </Card>

  <Card title="AutoGen" icon="robot" href="/pt-BR/quickstarts/autogen">
    Ferramentas do Firecrawl nas equipes multiagente do Microsoft AutoGen.
  </Card>
</CardGroup>

<div id="sdks">
  ## SDKs
</div>

SDKs oficiais, com tipagem, que abrangem toda a API do Firecrawl. Aponte seu agente para a linguagem correspondente à sua stack.

<CardGroup cols={3}>
  <Card title="Python" icon="python" href="/pt-BR/sdks/python" />

  <Card title="Node" icon="node-js" href="/pt-BR/sdks/node" />

  <Card title="Go" icon="golang" href="/pt-BR/sdks/go" />

  <Card title="Java" icon="java" href="/pt-BR/sdks/java" />

  <Card title="Ruby" icon="gem" href="/pt-BR/sdks/ruby" />

  <Card title="Rust" icon="rust" href="/pt-BR/sdks/rust" />

  <Card title=".NET" icon="microsoft" href="/pt-BR/sdks/dotnet" />

  <Card title="PHP" icon="php" href="/pt-BR/sdks/php" />

  <Card title="Elixir" icon="droplet" href="/pt-BR/sdks/elixir" />

  <Card title="CLI" icon="terminal" href="/pt-BR/sdks/cli" />
</CardGroup>

O Firecrawl também oferece bindings de SDK de primeira classe para os principais SDKs de LLM e frameworks de agente — veja [SDKs e frameworks de LLM](/pt-BR/developer-guides/llm-sdks-and-frameworks/openai) para OpenAI, Anthropic, Gemini, Google ADK, Vercel AI SDK, LangChain, LangGraph, LlamaIndex, Mastra e ElevenAgents.