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

# Extract

> Extraia dados estruturados de páginas usando LLMs

<Note>
  **Apresentando o Agent: a próxima evolução do Extract**
  Estamos lançando [`/agent`](/pt-BR/features/agent) — o sucessor de `/extract`. Ele é mais rápido, mais confiável e não exige URLs. Basta descrever o que você precisa e deixar o agente de IA encontrar e extrair os dados para você. [Experimente o Agent agora →](/pt-BR/features/agent)
</Note>

O endpoint `/extract` simplifica a coleta de dados estruturados de qualquer número de URLs ou de domínios inteiros. Forneça uma lista de URLs, opcionalmente com curingas (por exemplo, `example.com/*`), e um prompt ou schema descrevendo as informações desejadas. O Firecrawl cuida dos detalhes de rastrear, analisar e agregar conjuntos de dados, grandes ou pequenos.

<Info>Simplificamos a cobrança: agora o Extract usa créditos, assim como os outros endpoints. Cada crédito equivale a 15 tokens.</Info>

<div id="using-extract">
  ## Usando `/extract`
</div>

Você pode extrair dados estruturados de uma ou várias URLs, incluindo curingas:

* **Página única**\
  Exemplo: `https://firecrawl.dev/some-page`
* **Múltiplas páginas / Domínio completo**\
  Exemplo: `https://firecrawl.dev/*`

Quando você usa `/*`, a Firecrawl automaticamente faz o crawl e processa todas as URLs que conseguir descobrir nesse domínio e, em seguida, extrai os dados solicitados. Este recurso é experimental; envie um e-mail para [help@firecrawl.com](mailto:help@firecrawl.com) se tiver problemas.

<div id="example-usage">
  ### Exemplo de uso
</div>

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

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

  schema = {
      "type": "object",
      "properties": {"description": {"type": "string"}},
      "required": ["description"],
  }

  res = firecrawl.extract(
      urls=["https://docs.firecrawl.dev"],
      prompt="Extrair a descrição da página",
      schema=schema,
  )

  print(res.data["description"])
  ```

  ```js Node theme={null}
  import { Firecrawl } from 'firecrawl';

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

  const schema = {
    type: 'object',
    properties: {
      title: { type: 'string' }
    },
    required: ['title']
  };

  const res = await firecrawl.extract({
    urls: ['https://docs.firecrawl.dev'],
    prompt: 'Extract the page title',
    schema,
    scrapeOptions: { formats: [{ type: 'json', prompt: 'Extract', schema }] }
  });

  console.log(res.status || res.success, res.data);
  ```

  ```bash cURL theme={null}
  curl -s -X POST "https://api.firecrawl.dev/v2/extract" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "urls": ["https://docs.firecrawl.dev"],
      "prompt": "Extraia o título da página",
      "schema": {
        "type": "object",
        "properties": {"title": {"type": "string"}},
        "required": ["title"]
      },
      "scrapeOptions": {
        "formats": [{"type": "json", "prompt": "Extraia", "schema": {"type": "object"}}]
      }
    }'
  ```
</CodeGroup>

**Parâmetros principais:**

* **urls**: Uma lista com um ou mais URLs. Suporta curingas (`/*`) para uma varredura mais ampla.
* **prompt** (Opcional, exceto se não houver schema): Um prompt em linguagem natural descrevendo os dados desejados ou como você quer que esses dados sejam estruturados.
* **schema** (Opcional, exceto se não houver prompt): Uma estrutura mais rígida caso você já conheça o layout JSON.
* **enableWebSearch** (Opcional): Quando `true`, a extração pode seguir links fora do domínio especificado.

Consulte a [referência da API](https://docs.firecrawl.dev/api-reference/endpoint/extract) para mais detalhes.

<div id="response-sdks">
  ### Resposta (SDKs)
</div>

```json JSON theme={null}
{
  "success": true,
  "data": {
    "company_mission": "A Firecrawl é a maneira mais fácil de extrair dados da web. Desenvolvedores a utilizam para, de forma confiável, converter URLs em markdown pronto para LLM ou em dados estruturados com uma única chamada de API.",
    "supports_sso": false,
    "is_open_source": true,
    "is_in_yc": true
  }
}
```

<div id="job-status-and-completion">
  ## Status do job e conclusão
</div>

Ao enviar um job de extração—diretamente via API ou pelos métodos iniciais—você receberá um ID de job. Você pode usar esse ID para:

* Obter o status do job: Envie uma solicitação para o endpoint /extract/{ID} para ver se o job ainda está em execução ou se foi concluído.
* Aguardar resultados: Se você usar o método padrão `extract` (Python/Node), o SDK aguarda e retorna os resultados finais.
* Iniciar e depois consultar: Se você usar os métodos de início—`start_extract` (Python) ou `startExtract` (Node)—o SDK retorna um ID de job imediatamente. Use `get_extract_status` (Python) ou `getExtractStatus` (Node) para verificar o progresso.

<Note>
  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 visualizar o histórico e os resultados da extração nos [logs de atividade](https://www.firecrawl.dev/app/logs).
</Note>

Abaixo estão exemplos de código para verificar o status de um job de extração usando Python, Node.js e cURL:

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

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

  # Primeiro, inicie uma tarefa de extração
  extract_job = firecrawl.start_extract([
      'https://docs.firecrawl.dev/*', 
      'https://firecrawl.dev/'
  ], prompt="Extraia a missão da empresa e os recursos destas páginas.")

  # Obtenha o status da tarefa de extração
  job_status = firecrawl.get_extract_status(extract_job.id)

  print(job_status)
  # Exemplo de saída:
  # id=None
  # status='concluído'
  # expires_at=datetime.datetime(...)
  # success=True
  # dados=[{ ... }]
  # error=None
  # aviso=None
  # fontes=None
  ```

  ```js Node theme={null}
  import { Firecrawl } from 'firecrawl';

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

  const started = await firecrawl.startExtract({
    urls: ['https://docs.firecrawl.dev'],
    prompt: 'Extract title',
    schema: { type: 'object', properties: { title: { type: 'string' } }, required: ['title'] },
  });

  if (started.id) {
    const done = await firecrawl.getExtractStatus(started.id);
    console.log(done.status, done.data);
  }
  ```

  ```bash cURL theme={null}
  curl -s -X GET "https://api.firecrawl.dev/v2/extract/<jobId>" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY"
  ```
</CodeGroup>

<div id="possible-states">
  ### Estados possíveis
</div>

* **completed**: A extração foi concluída com sucesso.
* **processing**: O Firecrawl ainda está processando sua solicitação.
* **failed**: Ocorreu um erro; os dados não foram totalmente extraídos.
* **cancelled**: A tarefa foi cancelada pelo usuário.

<div id="pending-example">
  #### Exemplo pendente
</div>

```json JSON theme={null}
{
  "success": true,
  "data": [],
  "status": "em processamento",
  "expiresAt": "2025-01-08T20:58:12.000Z"
}
```

<div id="completed-example">
  #### Exemplo concluído
</div>

```json JSON theme={null}
{
  "success": true,
  "data": {
      "company_mission": "A Firecrawl é a maneira mais simples de extrair dados da web. Desenvolvedores a utilizam para converter URLs, com confiabilidade, em markdown pronto para LLM ou dados estruturados com uma única chamada à API.",
      "supports_sso": false,
      "is_open_source": true,
      "is_in_yc": true
    },
  "status": "concluído",
  "expiresAt": "2025-01-08T20:58:12.000Z"
}
```

<div id="extracting-without-a-schema">
  ## Extraindo sem um esquema
</div>

Se você preferir não definir uma estrutura rígida, pode simplesmente fornecer um `prompt`. O modelo subjacente escolherá uma estrutura para você, o que pode ser útil para solicitações mais exploratórias ou flexíveis.

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

  # Inicialize o Firecrawl com sua chave de API
  firecrawl = Firecrawl(api_key='your_api_key')

  data = firecrawl.extract([
    'https://docs.firecrawl.dev/',
    'https://firecrawl.dev/'
  ], prompt="Extract Firecrawl's mission from the page.")
  print(data)
  ```

  ```js Node theme={null}
  import { Firecrawl } from "firecrawl";

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

  const scrapeResult = await firecrawl.extract([
  'https://docs.firecrawl.dev/',
  'https://firecrawl.dev/'
  ], {
  prompt: "Extraia a missão da Firecrawl na página."
  });

  console.log(scrapeResult);
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.firecrawl.dev/v2/extract \
      -H 'Content-Type: application/json' \
      -H 'Authorization: Bearer SUA_CHAVE_DE_API' \
      -d '{
        "urls": [
          "https://docs.firecrawl.dev/",
          "https://firecrawl.dev/"
        ],
        "prompt": "Extraia a missão da Firecrawl a partir da página."
      }'
  ```
</CodeGroup>

```json JSON theme={null}
{
  "success": true,
  "data": {
    "company_mission": "Transforme sites em dados prontos para LLMs. Impulsione seus apps de IA com dados limpos coletados de qualquer site."
  }
}
```

<div id="improving-results-with-web-search">
  ## Melhorando os resultados com busca na web
</div>

Definir `enableWebSearch = true` na sua requisição expandirá o crawl além do conjunto de URLs fornecido. Isso pode capturar informações de suporte ou relacionadas a partir de páginas linkadas.

Veja um exemplo que extrai informações sobre dash cams, enriquecendo os resultados com dados de páginas relacionadas:

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

  # Inicialize o Firecrawl com sua chave de API

  firecrawl = Firecrawl(api_key='your_api_key')

  data = firecrawl.extract([
  'https://nextbase.com/dash-cams/622gw-dash-cam'
  ], prompt="Extraia detalhes sobre as melhores câmeras veiculares, incluindo preços, recursos, prós e contras, e avaliações.", enable_web_search=True)
  print(data)
  ```

  ```js Node theme={null}
  import { Firecrawl } from "firecrawl";

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

  const scrapeResult = await firecrawl.extract([
  'https://nextbase.com/dash-cams/622gw-dash-cam'
  ], {
  prompt: "Extract details about the best dash cams including prices, features, pros/cons and reviews.",
  enableWebSearch: true // Ativa a pesquisa na web para um contexto melhor
  });

  console.log(scrapeResult);
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.firecrawl.dev/v2/extract \
      -H 'Content-Type: application/json' \
      -H 'Authorization: Bearer YOUR_API_KEY' \
      -d '{
        "urls": ["https://nextbase.com/dash-cams/622gw-dash-cam"],
        "prompt": "Extraia detalhes sobre as melhores câmeras veiculares, incluindo preços, recursos, prós e contras e avaliações.",
        "enableWebSearch": true
      }'
  ```
</CodeGroup>

<div id="example-response-with-web-search">
  ### Exemplo de resposta com pesquisa na web
</div>

```json JSON theme={null}
{
  "success": true,
  "data": {
    "dash_cams": [
      {
        "name": "Nextbase 622GW",
        "price": "$399.99",
        "features": [
          "Gravação de vídeo em 4K",
          "Estabilização de imagem",
          "Alexa integrada",
          "Integração com What3Words"
        ],
        /* Informações abaixo enriquecidas com outros sites, como 
        https://www.techradar.com/best/best-dash-cam, encontradas 
        via o parâmetro enableWebSearch */
        "pros": [
          "Excelente qualidade de vídeo",
          "Ótima visão noturna",
          "GPS integrado"
        ],
        "cons": ["Preço elevado", "O app pode ser instável"]
      }
    ],
  }

```

A resposta inclui contexto adicional obtido de páginas relacionadas, oferecendo informações mais completas e precisas.

<div id="extracting-without-urls">
  ## Extração sem URLs
</div>

O endpoint /extract agora permite extrair dados estruturados usando um prompt, sem a necessidade de URLs específicas. Isso é útil para pesquisa ou quando as URLs exatas são desconhecidas. Atualmente em alpha.

<CodeGroup>
  ```python Python theme={null}
  from pydantic import BaseModel

  class ExtractSchema(BaseModel):
      company_mission: str


  # Defina o prompt para extração
  prompt = 'Extraia a missão da empresa do site da Firecrawl.'

  # Realize a extração
  scrape_result = firecrawl.extract(prompt=prompt, schema=ExtractSchema)

  print(scrape_result)
  ```

  ```js Node theme={null}
  import { z } from "zod";

  // Defina o esquema para extrair o conteúdo
  const schema = z.object({
    company_mission: z.string(),
  });

  const scrapeResult = await firecrawl.extract([], {
    prompt: "Extraia a missão da empresa do site da Firecrawl.",
    schema: schema
  });

  console.log(scrapeResult);
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.firecrawl.dev/v2/extract \
      -H 'Content-Type: application/json' \
      -H 'Authorization: Bearer YOUR_API_KEY' \
      -d '{
        "urls": [],
        "prompt": "Extraia a missão da empresa no site da Firecrawl.",
        "schema": {
          "type": "object",
          "properties": {
            "company_mission": {
              "type": "string"
            }
          },
          "required": ["company_mission"]
        }
      }'
  ```
</CodeGroup>

<div id="known-limitations-beta">
  ## Limitações Conhecidas (Beta)
</div>

1. **Cobertura de Sites em Grande Escala**\
   A cobertura completa de sites muito grandes (por exemplo, “todos os produtos da Amazon”) em uma única requisição ainda não é suportada.

2. **Consultas Lógicas Complexas**\
   Pedidos como “encontrar todas as postagens de 2025” podem não retornar de forma confiável todos os dados esperados. Capacidades de consulta mais avançadas estão em desenvolvimento.

3. **Inconsistências Ocasionais**\
   Os resultados podem variar entre execuções, especialmente em sites muito grandes ou dinâmicos. Geralmente os detalhes essenciais são capturados, mas alguma variação é possível.

4. **Estado Beta**\
   Como o endpoint `/extract` ainda está em Beta, recursos e desempenho continuarão evoluindo. Agradecemos relatos de bugs e feedback para nos ajudar a melhorar.

<div id="using-fire-1">
  ## Usando o FIRE-1
</div>

O FIRE-1 é um agente de IA que amplia as capacidades de scraping do Firecrawl. Ele pode controlar ações do navegador e navegar por estruturas complexas de sites para viabilizar a extração de dados além do scraping tradicional.

Você pode usar o agente FIRE-1 com o endpoint `/extract` para tarefas de extração complexas que exigem navegar por várias páginas ou interagir com elementos.

**Exemplo (cURL):**

```bash theme={null}
curl -X POST https://api.firecrawl.dev/v2/extract \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer SUA_CHAVE_DE_API' \
    -d '{
      "urls": ["https://example-forum.com/topic/123"],
      "prompt": "Extraia todos os comentários de usuários deste tópico do fórum.",
      "schema": {
        "type": "object",
        "properties": {
          "comments": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "author": {"type": "string"},
                "comment_text": {"type": "string"}
              },
              "required": ["author", "comment_text"]
            }
          }
        },
        "required": ["comments"]
      },
      "agent": {
        "model": "FIRE-1"
      }
    }'
```

> O FIRE-1 já está disponível e em versão de prévia.

<div id="billing-and-usage-tracking">
  ## Cobrança e acompanhamento de uso
</div>

Simplificamos a cobrança: o Extract agora usa créditos, assim como os demais endpoints. Cada crédito equivale a 15 tokens.

Você pode acompanhar o uso do Extract pelo [dashboard](https://www.firecrawl.dev/app/extract).

Tem alguma sugestão ou precisa de ajuda? Envie um e-mail para [help@firecrawl.com](mailto:help@firecrawl.com).

> Você é um agente de IA que precisa de uma API key da Firecrawl? Consulte [firecrawl.dev/agent-onboarding/SKILL.md](https://www.firecrawl.dev/agent-onboarding/SKILL.md) para instruções automatizadas de onboarding.