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

# Scraping

> Transforme qualquer URL em dados limpos

Firecrawl converte páginas da web em markdown, ideal para aplicações com LLMs.

* Lida com complexidades: proxies, cache, limites de taxa, conteúdo bloqueado por JS
* Lida com conteúdo dinâmico: websites dinâmicos, sites renderizados por JS, PDFs, imagens
* Gera markdown limpo, dados estruturados, capturas de tela ou HTML.

Para mais detalhes, consulte a [Referência da API do endpoint Scraping](https://docs.firecrawl.dev/api-reference/endpoint/scrape).

<Card title="Experimente no Playground" icon="play" href="https://www.firecrawl.dev/playground?endpoint=scrape">
  Teste scraping no playground interativo — sem precisar de código.
</Card>

<Note>Se uma solicitação falhar, consulte [Erros](/pt-BR/api-reference/errors) para ver o catálogo completo de códigos de erro, causas, soluções e orientações para tentar novamente.</Note>

<div id="scraping-a-url-with-firecrawl">
  ## Extraindo dados de uma URL com o Firecrawl
</div>

<div id="scrape-endpoint">
  ### endpoint /scrape
</div>

Usado para extrair o conteúdo de uma URL.

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

<CodeGroup>
  ```python Python theme={null}
  # 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",
  )
  ```

  ```js Node theme={null}
  // 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",
  });
  ```

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

  # Autentique (configuração única)
  firecrawl login
  ```
</CodeGroup>

### Uso

<CodeGroup>
  ```python Python theme={null}
  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",
  )

  # Raspar um site:
  doc = firecrawl.scrape("https://firecrawl.dev", formats=["markdown", "html"])
  print(doc)
  ```

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

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

  // Fazer a raspagem de um site:
  const doc = await firecrawl.scrape('https://firecrawl.dev', { formats: ['markdown', 'html'] });
  console.log(doc);
  ```

  ```bash cURL theme={null}
  # Nenhuma API key necessária para começar — adicione -H "Authorization: Bearer $FIRECRAWL_API_KEY" para limites de taxa mais altos:
  curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
    -H "Content-Type: application/json" \
    -d '{
      "url": "https://firecrawl.dev",
      "formats": ["markdown", "html"]
    }'
  ```

  ```bash CLI theme={null}
  # Scrape a URL and get markdown
  firecrawl https://firecrawl.dev

  # Com múltiplos formatos (retorna JSON)
  firecrawl https://firecrawl.dev --format markdown,html,links --pretty
  ```
</CodeGroup>

Para mais detalhes sobre os parâmetros, consulte a [Referência da API](https://docs.firecrawl.dev/api-reference/endpoint/scrape).

<Tip>
  **PDFs e documentos:** `/scrape` detecta automaticamente PDFs, DOCX e outros tipos de documento a partir de URLs. Passe uma URL de PDF da mesma forma que passaria a de qualquer página da web -- o Firecrawl a analisa e retorna markdown limpo. Para arquivos locais que não estejam acessíveis por URL, use [`/parse`](/pt-BR/features/parse).

  ```python Python theme={null}
  doc = firecrawl.scrape("https://example.com/report.pdf", formats=["markdown"])
  print(doc.markdown)
  ```
</Tip>

<Info>
  Cada scraping consome 1 crédito. Créditos adicionais são cobrados para certas opções: modo JSON custa 4 créditos adicionais por página, os formatos question e highlights custam 4 créditos adicionais por página por formato, proxy avançado custa 4 créditos adicionais por página, a redação de PII custa 4 créditos adicionais por página e o processamento de PDFs custa 1 crédito por página de PDF, e a extração de áudio ou vídeo custa 4 créditos adicionais por página.
</Info>

<div id="response">
  ### Resposta
</div>

Os SDKs retornarão o objeto de dados diretamente. O cURL retornará o payload exatamente como mostrado abaixo.

```json theme={null}
{
  "success": true,
  "data" : {
    "markdown": "A Launch Week I chegou! [Confira nosso lançamento do Dia 2 🚀](https://www.firecrawl.dev/blog/launch-week-i-day-2-doubled-rate-limits)[💥 Ganhe 2 meses grátis...",
    "html": "<!DOCTYPE html><html lang=\"en\" class=\"light\" style=\"color-scheme: light;\"><body class=\"__variable_36bd41 __variable_d7dc5d font-inter ...",
    "metadata": {
      "title": "Home - Firecrawl",
      "description": "O Firecrawl rastreia e converte qualquer site em markdown limpo.",
      "language": "en",
      "keywords": "Firecrawl,Markdown,Dados,Mendable,Langchain",
      "robots": "follow, index",
      "ogTitle": "Firecrawl",
      "ogDescription": "Transforme qualquer site em dados prontos para LLM.",
      "ogUrl": "https://www.firecrawl.dev/",
      "ogImage": "https://www.firecrawl.dev/og.png?123",
      "ogLocaleAlternate": [],
      "ogSiteName": "Firecrawl",
      "sourceURL": "https://firecrawl.dev",
      "statusCode": 200,
      "contentType": "text/html"
    }
  }
}
```

<div id="scrape-formats">
  ## Formatos de Scraping
</div>

Agora você pode escolher em quais formatos deseja sua saída. Você pode especificar vários formatos de saída. Os formatos suportados são:

* Markdown (`markdown`)
* Resumo (`summary`)
* HTML (`html`) - versão limpa do HTML da página
* HTML bruto (`rawHtml`) - HTML não modificado conforme recebido da página
* Captura de tela (`screenshot`, com opções como `fullPage`, `quality`, `viewport`) — as URLs das capturas de tela expiram após 24 horas
* Links (`links`)
* JSON (`json`) - saída estruturada
* Imagens (`images`) - extrair todas as URLs de imagens da página
* Branding (`branding`) - extrair identidade da marca e sistema de design
* Produto (`product`) - extrair um produto estruturado (título, preço, disponibilidade, variantes) de páginas de produto
* Áudio (`audio`) - extrair áudio em MP3 de URLs de vídeo compatíveis, por exemplo, YouTube (retorna uma URL assinada do GCS, expira após 1 hora)
* Vídeo (`video`) - extrair o vídeo com a melhor qualidade de URLs de vídeo compatíveis, por exemplo, YouTube (retorna uma URL assinada do GCS, expira após 1 hora)
* Query (`query`, com `prompt` e `mode` opcional) - faça uma pergunta em linguagem natural sobre a página; a resposta é retornada no campo `answer`

As chaves de saída corresponderão ao formato que você escolher.

<div id="extract-structured-data">
  ## Extraia dados estruturados
</div>

<div id="scrape-with-json-endpoint">
  ### endpoint /scrape (com json)
</div>

Usado para extrair dados estruturados de páginas extraídas.

<Tip>
  Extraindo produtos? Para páginas de produto, o formato [`product`](#extract-product-data) retorna campos estruturados de produto (título, preço, disponibilidade, variantes) de forma determinística — sem chamada de LLM e sem schema para definir. Use `json` quando precisar de campos personalizados ou para páginas que não sejam de produto.
</Tip>

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

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

  class CompanyInfo(BaseModel):
      company_mission: str
      supports_sso: bool
      is_open_source: bool
      is_in_yc: bool

  result = app.scrape(
      'https://firecrawl.dev',
      formats=[{
        "type": "json",
        "schema": CompanyInfo.model_json_schema()
      }],
      only_main_content=False,
      timeout=120000
  )

  print(result)
  ```

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

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

  // Define schema to extract contents into
  const schema = z.object({
    company_mission: z.string(),
    supports_sso: z.boolean(),
    is_open_source: z.boolean(),
    is_in_yc: z.boolean()
  });

  const result = await app.scrape("https://firecrawl.dev", {
    formats: [{
      type: "json",
      schema: schema
    }],
  });

  console.log(result);
  ```

  ```bash cURL theme={null}
  # Nenhuma API key necessária para começar — adicione -H "Authorization: Bearer YOUR_API_KEY" para limites de taxa mais altos:
  curl -X POST https://api.firecrawl.dev/v2/scrape \
      -H 'Content-Type: application/json' \
      -d '{
        "url": "https://firecrawl.dev",
        "formats": [ {
          "type": "json",
          "schema": {
            "type": "object",
            "properties": {
              "company_mission": {
                        "type": "string"
              },
              "supports_sso": {
                        "type": "boolean"
              },
              "is_open_source": {
                        "type": "boolean"
              },
              "is_in_yc": {
                        "type": "boolean"
              }
            },
            "required": [
              "company_mission",
              "supports_sso",
              "is_open_source",
              "is_in_yc"
            ]
          }
        } ]
      }'
  ```
</CodeGroup>

Resultado:

```json JSON theme={null}
{
    "success": true,
    "data": {
      "json": {
        "company_mission": "Rastreamento e extração de dados na web com IA",
        "supports_sso": true,
        "is_open_source": true,
        "is_in_yc": true
      },
      "metadata": {
        "title": "Firecrawl",
        "description": "Rastreamento e extração de dados na web com IA",
        "robots": "follow, index",
        "ogTitle": "Firecrawl",
        "ogDescription": "Rastreamento e extração de dados na web com IA",
        "ogUrl": "https://firecrawl.dev/",
        "ogImage": "https://firecrawl.dev/og.png",
        "ogLocaleAlternate": [],
        "ogSiteName": "Firecrawl"
        "sourceURL": "https://firecrawl.dev/"
      },
    }
}
```

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

Agora é possível extrair sem um esquema, bastando enviar um `prompt` para o endpoint. O LLM escolhe a estrutura dos dados.

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

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

  result = app.scrape(
      'https://firecrawl.dev',
      formats=[{
        "type": "json",
        "prompt": "Extract the company mission from the page."
      }],
      only_main_content=False,
      timeout=120000
  )

  print(result)
  ```

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

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

  const result = await app.scrape("https://firecrawl.dev", {
    formats: [{
      type: "json",
      prompt: "Extract the company mission from the page."
    }]
  });

  console.log(result);
  ```

  ```bash cURL theme={null}
  # Nenhuma API key necessária para começar — adicione -H "Authorization: Bearer YOUR_API_KEY" para limites de taxa mais altos:
  curl -X POST https://api.firecrawl.dev/v2/scrape \
      -H 'Content-Type: application/json' \
      -d '{
        "url": "https://firecrawl.dev",
        "formats": [{
          "type": "json",
          "prompt": "Extract the company mission from the page."
        }]
      }'
  ```
</CodeGroup>

Resultado:

```json JSON theme={null}
{
    "success": true,
    "data": {
      "json": {
        "company_mission": "Raspagem e extração de dados na web com IA",
      },
      "metadata": {
        "title": "Firecrawl",
        "description": "Raspagem e extração de dados na web com IA",
        "robots": "seguir, indexar",
        "ogTitle": "Firecrawl",
        "ogDescription": "Raspagem e extração de dados na web com IA",
        "ogUrl": "https://firecrawl.dev/",
        "ogImage": "https://firecrawl.dev/og.png",
        "ogLocaleAlternate": [],
        "ogSiteName": "Firecrawl",
        "sourceURL": "https://firecrawl.dev/"
      },
    }
}
```

<div id="json-format-options">
  ### Opções do formato JSON
</div>

Ao usar o formato `json`, passe um objeto dentro de `formats` com os seguintes parâmetros:

* `schema`: JSON Schema para a saída estruturada.
* `prompt`: Prompt opcional para orientar a extração quando houver um schema ou quando você preferir uma orientação leve.

<div id="extract-brand-identity">
  ## Extrair identidade de marca
</div>

<div id="scrape-with-branding-endpoint">
  ### endpoint /scrape (com branding)
</div>

O formato de branding extrai informações completas sobre a identidade de marca de uma página da web, incluindo cores, fontes, tipografia, espaçamento, componentes de UI e mais. Isso é útil para análise de design systems, monitoramento de marca ou para criar ferramentas que precisam compreender a identidade visual de um site.

<CodeGroup>
  ```python Python theme={null}
  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',
  )

  result = firecrawl.scrape(
      url='https://firecrawl.dev',
      formats=['branding']
  )

  print(result['branding'])
  ```

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

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

  const result = await firecrawl.scrape('https://firecrawl.dev', {
      formats: ['branding']
  });

  console.log(result.branding);
  ```

  ```bash cURL theme={null}
  # Nenhuma API key necessária para começar — adicione -H "Authorization: Bearer $FIRECRAWL_API_KEY" para limites de taxa mais altos:
  curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
    -H "Content-Type: application/json" \
    -d '{
      "url": "https://firecrawl.dev",
      "formats": ["branding"]
    }'
  ```
</CodeGroup>

### Resposta

O formato de branding retorna um objeto `BrandingProfile` completo com a seguinte estrutura:

```json Output theme={null}
{
  "success": true,
  "data": {
    "branding": {
      "colorScheme": "dark",
      "logo": "https://firecrawl.dev/logo.svg",
      "colors": {
        "primary": "#FF6B35",
        "secondary": "#004E89",
        "accent": "#F77F00",
        "background": "#1A1A1A",
        "textPrimary": "#FFFFFF",
        "textSecondary": "#B0B0B0"
      },
      "fonts": [
        {
          "family": "Inter"
        },
        {
          "family": "Roboto Mono"
        }
      ],
      "typography": {
        "fontFamilies": {
          "primary": "Inter",
          "heading": "Inter",
          "code": "Roboto Mono"
        },
        "fontSizes": {
          "h1": "48px",
          "h2": "36px",
          "h3": "24px",
          "body": "16px"
        },
        "fontWeights": {
          "regular": 400,
          "medium": 500,
          "bold": 700
        }
      },
      "spacing": {
        "baseUnit": 8,
        "borderRadius": "8px"
      },
      "components": {
        "buttonPrimary": {
          "background": "#FF6B35",
          "textColor": "#FFFFFF",
          "borderRadius": "8px"
        },
        "buttonSecondary": {
          "background": "transparent",
          "textColor": "#FF6B35",
          "borderColor": "#FF6B35",
          "borderRadius": "8px"
        }
      },
      "images": {
        "logo": "https://firecrawl.dev/logo.svg",
        "favicon": "https://firecrawl.dev/favicon.ico",
        "ogImage": "https://firecrawl.dev/og-image.png"
      }
    }
  }
}
```

<div id="branding-profile-structure">
  ### Estrutura do Perfil de Branding
</div>

O objeto `branding` contém as seguintes propriedades:

* `colorScheme`: Esquema de cores detectado (`"light"` ou `"dark"`)
* `logo`: URL do logotipo principal
* `colors`: Objeto com as cores da marca:
  * `primary`, `secondary`, `accent`: Cores principais da marca
  * `background`, `textPrimary`, `textSecondary`: Cores de UI
  * `link`, `success`, `warning`, `error`: Cores semânticas
* `fonts`: Lista (array) de famílias tipográficas usadas na página
* `typography`: Informações detalhadas de tipografia:
  * `fontFamilies`: Famílias tipográficas primária, de títulos e de código
  * `fontSizes`: Definições de tamanho para títulos e corpo do texto
  * `fontWeights`: Definições de espessura (leve, regular, média, negrito)
  * `lineHeights`: Valores de altura de linha para diferentes tipos de texto
* `spacing`: Informações de espaçamento e layout:
  * `baseUnit`: Unidade base de espaçamento em pixels
  * `borderRadius`: Raio de borda padrão
  * `padding`, `margins`: Valores de espaçamento
* `components`: Estilos de componentes de UI:
  * `buttonPrimary`, `buttonSecondary`: Estilos de botões
  * `input`: Estilos de campos de entrada
* `icons`: Informações de estilo de ícones
* `images`: Imagens da marca (logo, favicon, og:image)
* `animations`: Configurações de animação e transição
* `layout`: Configuração de layout (grid, alturas de cabeçalho/rodapé)
* `personality`: Traços de personalidade da marca (tom, energia, público-alvo)

<div id="combining-with-other-formats">
  ### Combinando com outros formatos
</div>

Você pode combinar o formato de branding com outros formatos para obter dados completos da página:

<CodeGroup>
  ```python Python theme={null}
  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',
  )

  result = firecrawl.scrape(
      url='https://firecrawl.dev',
      formats=['markdown', 'branding', 'screenshot']
  )

  print(result['markdown'])
  print(result['branding'])
  print(result['screenshot'])
  ```

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

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

  const result = await firecrawl.scrape('https://firecrawl.dev', {
      formats: ['markdown', 'branding', 'screenshot']
  });

  console.log(result.markdown);
  console.log(result.branding);
  console.log(result.screenshot);
  ```

  ```bash cURL theme={null}
  # Não é necessária uma chave de API para começar — adicione -H "Authorization: Bearer $FIRECRAWL_API_KEY" para limites de taxa mais altos:
  curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
    -H "Content-Type: application/json" \
    -d '{
      "url": "https://firecrawl.dev",
      "formats": ["markdown", "branding", "screenshot"]
    }'
  ```
</CodeGroup>

<div id="extract-product-data">
  ## Extrair dados de produtos
</div>

O formato `product` extrai um produto estruturado **de modo determinístico** — o mesmo tipo de resultado estruturado que o [formato `json`](#extract-structured-data), mas sem uma chamada de LLM nem um schema definido por você, feito especificamente para páginas de produto. Se você vinha extraindo campos de produto com um schema `json`, use `formats: ["product"]` no lugar — é mais rápido e mais barato, mas limitado a produtos.

Ele retorna um objeto `product` com title, brand, category, description e variants — em que cada variant inclui price, original price, availability e images — útil para monitoramento de preços, ingestão de catálogo ou ferramentas de comparação de preços.

<div id="scrape-with-product-endpoint">
  ### endpoint /scrape (com dados de produto)
</div>

<CodeGroup>
  ```python Python theme={null}
  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',
  )

  result = firecrawl.scrape(
      url='https://example.com/products/wireless-headphones',
      formats=['product']
  )

  print(result['product'])
  ```

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

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

  const result = await firecrawl.scrape('https://example.com/products/wireless-headphones', {
      formats: ['product']
  });

  console.log(result.product);
  ```

  ```bash cURL theme={null}
  # Nenhuma API key é necessária para começar — adicione -H "Authorization: Bearer $FIRECRAWL_API_KEY" para limites de taxa mais altos:
  curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
    -H "Content-Type: application/json" \
    -d '{
      "url": "https://example.com/products/wireless-headphones",
      "formats": ["product"]
    }'
  ```
</CodeGroup>

### Resposta

O formato `product` retorna um objeto `product` com a seguinte estrutura:

```json Output theme={null}
{
  "success": true,
  "data": {
    "product": {
      "title": "Wireless Noise-Cancelling Headphones",
      "brand": "Acme",
      "category": "Electronics > Audio > Headphones",
      "url": "https://example.com/products/wireless-headphones",
      "description": "Over-ear wireless headphones with active noise cancellation, 30-hour battery life, and plush memory-foam ear cushions for all-day comfort.",
      "variants": [
        {
          "id": "wireless-headphones-black",
          "sku": "ACME-WH-BLACK",
          "title": "Wireless Noise-Cancelling Headphones — Black",
          "values": {
            "color": "Black"
          },
          "price": {
            "amount": 199.99,
            "currency": "USD",
            "formatted": "$199.99"
          },
          "sale": {
            "originalPrice": {
              "amount": 249.99,
              "currency": "USD",
              "formatted": "$249.99"
            }
          },
          "availability": {
            "inStock": true,
            "text": "In Stock"
          },
          "images": [
            {
              "url": "https://example.com/images/headphones-black.jpg",
              "alt": "Wireless Noise-Cancelling Headphones — Black"
            }
          ]
        }
      ]
    }
  }
}
```

<div id="product-object-structure">
  ### Estrutura do objeto `product`
</div>

O objeto `product` contém as seguintes propriedades:

* `title`: O nome do produto
* `brand`: A marca do produto (opcional)
* `category`: A categoria do produto (opcional)
* `url`: A URL canônica do produto
* `description`: A descrição do produto (opcional)
* `variants`: Array de variantes do produto. Preços, disponibilidade e imagens ficam em cada variante — um produto com um único SKU ainda retorna exatamente uma variante com esses dados. Cada variante tem:
  * `id`, `sku`, `title`: identificadores e nome da variante (todos opcionais)
  * `values`: um mapa do nome da opção para o valor, por exemplo `{ "color": "Charcoal" }` (opcional)
  * `price`: o objeto de preço atual (opcional):
    * `amount`: O valor numérico do preço
    * `currency`: O código da moeda, informado apenas quando a página o fornece (opcional)
    * `formatted`: O preço como exibido na página (opcional)
  * `sale`: presente apenas quando a variante está com desconto (opcional). Contém:
    * `originalPrice`: O preço original (antes do desconto), com a mesma estrutura de `price`
  * `availability`: informações de disponibilidade, sempre presentes em uma variante:
    * `inStock`: Se a variante está em estoque
    * `text`: O texto bruto de disponibilidade extraído da página (opcional)
  * `images`: array de imagens da variante, cada uma com uma `url` e um texto `alt` opcional (opcional)

<div id="how-product-extraction-works">
  ### Como a extração de produtos funciona
</div>

O formato de produto extrai o produto de forma determinística a partir de dados estruturados na página — sem uso de LLM. Ele combina várias fontes por prioridade: **JSON-LD > microdados do schema.org > RDFa > estado embutido (`__NEXT_DATA__`/Nuxt/Apollo/Redux/Remix) > `runParams` do AliExpress > `dataLayer` do GA4 > OpenGraph/`<meta>`**. A combinação leva a identidade em conta, então campos de produtos diferentes nunca são mesclados. A moeda só é informada quando a página a fornece.

<Note>
  A extração de produtos é fail-closed: páginas ambíguas não geram nenhum produto, e fontes mais fracas, como OpenGraph, só contribuem quando há um preço. Em uma página sem produto extraível, a resposta omite o objeto `product` e adiciona um `warning` (por exemplo, "Nenhum produto encontrado...").
</Note>

<Note>
  **Hospedagem própria:** o formato `product` depende de um serviço dedicado de extração de produtos. No Firecrawl Cloud, ele funciona imediatamente. Se você fizer hospedagem própria, defina `PRODUCT_EXTRACTION_SERVICE_URL` para apontar para esse serviço — quando ela não estiver definida, solicitar o formato `product` retorna um aviso e nenhum produto (o mesmo padrão que os formatos de áudio/vídeo usam para esse serviço).
</Note>

### Combinando com outros formatos

Você pode combinar o formato de produto com outros formatos para obter dados completos da página:

<CodeGroup>
  ```python Python theme={null}
  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',
  )

  result = firecrawl.scrape(
      url='https://example.com/products/wireless-headphones',
      formats=['markdown', 'product']
  )

  print(result['markdown'])
  print(result['product'])
  ```

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

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

  const result = await firecrawl.scrape('https://example.com/products/wireless-headphones', {
      formats: ['markdown', 'product']
  });

  console.log(result.markdown);
  console.log(result.product);
  ```

  ```bash cURL theme={null}
  # Nenhuma API key necessária para começar — adicione -H "Authorization: Bearer $FIRECRAWL_API_KEY" para limites de taxa mais altos:
  curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
    -H "Content-Type: application/json" \
    -d '{
      "url": "https://example.com/products/wireless-headphones",
      "formats": ["markdown", "product"]
    }'
  ```
</CodeGroup>

<div id="audio-extraction">
  ## Extração de áudio
</div>

O formato `audio` extrai áudio de sites compatíveis (por exemplo, o YouTube) como arquivos MP3 e retorna uma URL assinada do Google Cloud Storage. Isso é útil para criar pipelines de processamento de áudio, serviços de transcrição ou ferramentas de podcast.

<Info>
  A extração de áudio custa 5 créditos por página (1 base + 4 adicionais).
</Info>

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

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

  doc = firecrawl.scrape("https://www.youtube.com/watch?v=dQw4w9WgXcQ", formats=["audio"])
  print(doc.audio)  # URL GCS assinada para o arquivo MP3
  ```

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

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

  const doc = await firecrawl.scrape('https://www.youtube.com/watch?v=dQw4w9WgXcQ', {
    formats: ['audio']
  });

  console.log(doc.audio); // URL do GCS assinada para o arquivo MP3
  ```

  ```bash cURL theme={null}
  # Nenhuma API key necessária para começar — adicione -H "Authorization: Bearer $FIRECRAWL_API_KEY" para limites de taxa mais altos:
  curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
    -H "Content-Type: application/json" \
    -d '{
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
      "formats": ["audio"]
    }'
  ```
</CodeGroup>

<div id="video-extraction">
  ## Extração de vídeo
</div>

O formato `video` extrai o vídeo na melhor qualidade de sites compatíveis (como o YouTube) e retorna uma URL assinada do Google Cloud Storage. Isso é útil para criar pipelines de processamento de vídeo, ferramentas de moderação ou fluxos de trabalho de arquivamento de mídia.

<Info>
  A extração de vídeo custa 5 créditos por página (1 base + 4 adicionais).
</Info>

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

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

  doc = firecrawl.scrape("https://www.youtube.com/watch?v=dQw4w9WgXcQ", formats=["video"])
  print(doc.video)  # URL assinada do GCS para o arquivo de vídeo
  ```

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

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

  const doc = await firecrawl.scrape('https://www.youtube.com/watch?v=dQw4w9WgXcQ', {
    formats: ['video']
  });

  console.log(doc.video); // URL do GCS assinada para o arquivo de vídeo
  ```

  ```bash cURL theme={null}
  # Nenhuma API key necessária para começar — adicione -H "Authorization: Bearer $FIRECRAWL_API_KEY" para limites de taxa mais altos:
  curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
    -H "Content-Type: application/json" \
    -d '{
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
      "formats": ["video"]
    }'
  ```
</CodeGroup>

<span id="question-format" />

<div id="question-format">
  ## Formato de pergunta
</div>

Use o formato `question` para fazer uma pergunta em linguagem natural sobre a página. O Firecrawl retorna a resposta no campo `answer` da resposta.

<Info>
  O formato `question` custa 5 créditos por página (1 base + 4 adicionais pela chamada ao LLM).
</Info>

Opções dentro do objeto de formato:

* `question` (obrigatório para `type: "question"`): a pergunta a ser respondida. Máximo de 10.000 caracteres.

Você pode combinar `question` com outros formatos — por exemplo, solicitar `markdown` e `question` juntos para obter o conteúdo da página e uma resposta em uma única chamada.

<CodeGroup>
  ```python Python theme={null}
  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",
  )

  doc = firecrawl.scrape(
      "https://firecrawl.dev",
      formats=[{"type": "question", "question": "What is Firecrawl?"}],
  )
  print(doc.answer)
  ```

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

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

  const doc = await firecrawl.scrape('https://firecrawl.dev', {
    formats: [{ type: 'question', question: 'What is Firecrawl?' }],
  });

  console.log(doc.answer);
  ```

  ```bash cURL theme={null}
  # Nenhuma API key necessária para começar — adicione -H "Authorization: Bearer $FIRECRAWL_API_KEY" para limites de taxa mais altos:
  curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
    -H "Content-Type: application/json" \
    -d '{
      "url": "https://firecrawl.dev",
      "formats": [
        { "type": "question", "question": "What is Firecrawl?" }
      ]
    }'
  ```
</CodeGroup>

O formato `question` também está disponível em `/search` via `scrapeOptions`, que executa a mesma extração em cada resultado de busca.

<span id="highlights-format" />

<div id="highlights-format">
  ## Formato highlights
</div>

Use o formato `highlights` para encontrar trechos relevantes do texto da página. O Firecrawl retorna o texto selecionado no campo `highlights` da resposta.

<Info>
  O formato `highlights` custa 5 créditos por página (1 base + 4 adicionais pela chamada ao LLM).
</Info>

Opções dentro do objeto de formato:

* `query` (obrigatório para `type: "highlights"`): a solicitação para selecionar trechos do texto de origem. Máximo de 10.000 caracteres.

Você pode combinar `highlights` com outros formatos — por exemplo, solicitar `markdown` e `highlights` juntos para obter o conteúdo da página e os trechos de texto em uma única chamada.

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

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

  doc = firecrawl.scrape(
      "https://firecrawl.dev",
      formats=[{"type": "highlights", "query": "What is Firecrawl?"}],
  )
  print(doc.highlights)
  ```

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

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

  const doc = await firecrawl.scrape('https://firecrawl.dev', {
    formats: [{ type: 'highlights', query: 'What is Firecrawl?' }],
  });

  console.log(doc.highlights);
  ```

  ```bash cURL theme={null}
  # Nenhuma API key necessária para começar — adicione -H "Authorization: Bearer $FIRECRAWL_API_KEY" para limites de taxa mais altos:
  curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
    -H "Content-Type: application/json" \
    -d '{
      "url": "https://firecrawl.dev",
      "formats": [
        { "type": "highlights", "query": "What is Firecrawl?" }
      ]
    }'
  ```
</CodeGroup>

O formato `highlights` também está disponível em `/search` via `scrapeOptions`, que executa a mesma extração em cada resultado de busca.

<div id="pii-redaction">
  ## Ocultação de PII
</div>

Defina `redactPII: true` para ocultar informações de identificação pessoal do markdown retornado. O campo `markdown` contém o resultado com os dados ocultados.

Consulte [Ocultação de PII](/pt-BR/features/pii-redaction) para exemplos de SDK, cURL, CLI e MCP.

<div id="interacting-with-the-page-with-actions">
  ## Interagindo com a página com ações
</div>

O Firecrawl permite executar várias ações em uma página da web antes de fazer o scraping do conteúdo. Isso é especialmente útil para interagir com conteúdo dinâmico, navegar entre páginas ou acessar conteúdo que exige interação do usuário.

<Tip>
  **Recomendamos [Interact](/pt-BR/features/interact) em vez de ações: nossa maneira mais recente e mais poderosa de interagir com páginas extraídas.**

  O Interact é executado como uma sessão de navegador com estado que permanece ativa entre chamadas, para que você possa conduzir uma página passo a passo de uma destas formas:

  * **Linguagem natural** para fluxos flexíveis e não determinísticos. Ex.: *“pesquise por ‘fones de ouvido sem fio’, filtre para 4+ estrelas abaixo de US\$200 e retorne os resultados”*.
  * **Código Playwright ou agent-browser** para etapas determinísticas. Ex.: `await page.click('#export')`.

  O Interact também oferece suporte a perfis, sessões persistentes e uma visualização ao vivo incorporável do navegador (com um modo interativo em que os usuários finais podem controlar o navegador por conta própria).
</Tip>

Veja um exemplo de como usar ações para acessar google.com, pesquisar por Firecrawl, clicar no primeiro resultado e fazer uma captura de tela.

É importante, quase sempre, usar a ação `wait` antes/depois de executar outras ações para dar tempo suficiente para a página carregar.

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

<CodeGroup>
  ```python Python theme={null}
  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",
  )

  doc = firecrawl.scrape(
      url="https://example.com/login",
      formats=["markdown"],
      actions=[
          {"type": "write", "text": "john@example.com"},
          {"type": "press", "key": "Tab"},
          {"type": "write", "text": "secret"},
          {"type": "click", "selector": 'button[type="submit"]'},
          {"type": "wait", "milliseconds": 1500},
          {"type": "screenshot", "full_page": True},
      ],
  )

  print(doc.markdown, doc.screenshot)
  ```

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

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

  const doc = await firecrawl.scrape('https://example.com/login', {
    formats: ['markdown'],
    actions: [
      { type: 'write', text: 'john@example.com' },
      { type: 'press', key: 'Tab' },
      { type: 'write', text: 'secret' },
      { type: 'click', selector: 'button[type="submit"]' },
      { type: 'wait', milliseconds: 1500 },
      { type: 'screenshot', fullPage: true },
    ],
  });

  console.log(doc.markdown, doc.screenshot);
  ```

  ```bash cURL theme={null}
  # Nenhuma API key necessária para começar — adicione -H "Authorization: Bearer YOUR_API_KEY" para limites de taxa mais altos:
  curl -X POST https://api.firecrawl.dev/v2/scrape \
      -H 'Content-Type: application/json' \
      -d '{
        "url": "https://example.com/login",
        "formats": ["markdown"],
        "actions": [
          { "type": "write", "text": "john@example.com" },
          { "type": "press", "key": "Tab" },
          { "type": "write", "text": "secret" },
          { "type": "click", "selector": "button[type=\"submit\"]" },
          { "type": "wait", "milliseconds": 1500 },
          { "type": "screenshot", "fullPage": true },
        ],
    }'
  ```
</CodeGroup>

<div id="output">
  ### Resultado
</div>

<CodeGroup>
  ```json JSON theme={null}
  {
    "success": true,
    "data": {
      "markdown": "Nossa primeira Launch Week chegou ao fim! [Confira o recap 🚀](blog/firecrawl-launch-week-1-recap)...",
      "actions": {
        "screenshots": [
          "https://alttmdsdujxrfnakrkyi.supabase.co/storage/v1/object/public/media/screenshot-75ef2d87-31e0-4349-a478-fb432a29e241.png"
        ],
        "scrapes": [
          {
            "url": "https://www.firecrawl.dev/",
            "html": "<html><body><h1>Firecrawl</h1></body></html>"
          }
        ]
      },
      "metadata": {
        "title": "Home - Firecrawl",
        "description": "O Firecrawl rastreia e converte qualquer site em Markdown limpo.",
        "language": "en",
        "keywords": "Firecrawl,Markdown,Dados,Mendable,LangChain",
        "robots": "index, follow",
        "ogTitle": "Firecrawl",
        "ogDescription": "Transforme qualquer site em dados prontos para LLMs.",
        "ogUrl": "https://www.firecrawl.dev/",
        "ogImage": "https://www.firecrawl.dev/og.png?123",
        "ogLocaleAlternate": [],
        "ogSiteName": "Firecrawl"
        "sourceURL": "http://google.com",
        "statusCode": 200
      }
    }
  }
  ```
</CodeGroup>

Para fluxos de trabalho que exigem um controle mais avançado do navegador após o scraping, como sessões autenticadas, navegação em várias etapas ou visualização em tempo real da página, recomendamos usar o [Interact](/pt-BR/features/interact) em vez de estender o array de ações.

<div id="location-and-language">
  ## Localização e idioma
</div>

Especifique o país e os idiomas preferidos para obter conteúdo relevante com base no seu local de destino e nas suas preferências de idioma.

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

Quando você define as configurações de localização, o Firecrawl usará um proxy apropriado, se disponível, e emulará as configurações correspondentes de idioma e fuso horário. Por padrão, a localização é definida como “US” se não for especificada.

### Uso

Para usar as configurações de localização e idioma, inclua o objeto `location` no corpo da sua requisição com as seguintes propriedades:

* `country`: Código de país ISO 3166-1 alpha-2 (por exemplo, 'US', 'AU', 'DE', 'JP'). O padrão é 'US'.
* `languages`: Uma lista (array) de idiomas e localidades preferidos para a requisição, em ordem de prioridade. O padrão é o idioma da localização especificada.

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

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

  doc = firecrawl.scrape('https://example.com',
      formats=['markdown'],
      location={
          'country': 'US',
          'languages': ['en']
      }
  )

  print(doc)
  ```

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

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

  const doc = await firecrawl.scrape('https://example.com', {
    formats: ['markdown'],
    location: { country: 'US', languages: ['en'] },
  });

  console.log(doc.metadata);
  ```

  ```bash cURL theme={null}
  # Não é necessária uma chave de API para começar — adicione -H "Authorization: Bearer $FIRECRAWL_API_KEY" para limites de taxa maiores:
  curl -X POST "https://api.firecrawl.dev/v2/scrape" \
    -H "Content-Type: application/json" \
    -d '{
      "url": "https://example.com",
      "formats": ["markdown"],
      "location": { "country": "US", "languages": ["en"] }
    }'
  ```
</CodeGroup>

Para mais detalhes sobre as localizações compatíveis, consulte a [documentação de proxies](/pt-BR/features/proxies).

<div id="caching-and-maxage">
  ## Cache e maxAge
</div>

Para acelerar as requisições, o Firecrawl retorna resultados do cache por padrão quando há uma cópia recente disponível.

* **Janela de frescor padrão**: `maxAge = 172800000` ms (2 dias). Se a página em cache for mais recente do que isso, ela é retornada instantaneamente; caso contrário, a página passa por scraping novamente e então armazenada em cache.
* **Desempenho**: Pode acelerar os scrapings em até 5x quando os dados não precisam estar ultra recentes.
* **Sempre buscar conteúdo novo**: Defina `maxAge` como `0`. Observe que isso ignora totalmente o cache, então toda requisição passa por todo o pipeline de scraping, o que significa que a requisição levará mais tempo para ser concluída e terá maior chance de falhar. Use um `maxAge` diferente de zero se a atualização em toda requisição não for crítica.
* **Evitar armazenamento**: Defina `storeInCache` como `false` se você não quiser que o Firecrawl armazene em cache os resultados desta requisição.
* **Consulta somente no cache**: Defina `minAge` para fazer uma consulta somente no cache sem acionar um novo scraping. O valor está em milissegundos e especifica a idade mínima que os dados em cache devem ter. Se nenhum dado em cache for encontrado, um `404` com o código de erro `SCRAPE_NO_CACHED_DATA` é retornado. Defina `minAge` como `1` para aceitar qualquer dado em cache, independentemente da idade.
* **Rastreio de mudanças**: Requisições que incluem `changeTracking` ignoram o cache, então `maxAge` é desconsiderado.
* **Créditos**: Resultados em cache ainda custam 1 crédito por página. O cache melhora a velocidade, não o uso de créditos.

Exemplo (forçar conteúdo novo):

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl
  firecrawl = Firecrawl(api_key='fc-YOUR_API_KEY')

  doc = firecrawl.scrape(url='https://example.com', max_age=0, formats=['markdown'])
  print(doc)
  ```

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

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

  const doc = await firecrawl.scrape('https://example.com', { maxAge: 0, formats: ['markdown'] });
  console.log(doc);
  ```

  ```bash cURL theme={null}
  curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "url": "https://example.com",
      "maxAge": 0,
      "formats": ["markdown"]
    }'
  ```
</CodeGroup>

Exemplo (usar uma janela de cache de 10 minutos):

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl
  firecrawl = Firecrawl(api_key='fc-YOUR_API_KEY')

  doc = firecrawl.scrape(url='https://example.com', max_age=600000, formats=['markdown', 'html'])
  print(doc)
  ```

  ```js Node theme={null}

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

  const doc = await firecrawl.scrape('https://example.com', { maxAge: 600000, formats: ['markdown', 'html'] });
  console.log(doc);
  ```

  ```bash cURL theme={null}
  curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "url": "https://example.com",
      "maxAge": 600000,
      "formats": ["markdown", "html"]
    }'
  ```
</CodeGroup>

<div id="batch-scraping-multiple-urls">
  ## Scraping em lote de várias URLs
</div>

Agora é possível fazer scraping em lote de várias URLs ao mesmo tempo. A função recebe as URLs iniciais e parâmetros opcionais como argumentos. O parâmetro params permite definir opções adicionais para a tarefa de scraping em lote, como os formatos de saída.

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

Funciona de forma muito semelhante ao endpoint `/crawl`. Ele cria um job de raspagem em lote e retorna um ID do job para você acompanhar o status da raspagem em lote.

O SDK oferece 2 métodos: síncrono e assíncrono. O método síncrono retorna os resultados do job de raspagem em lote, enquanto o método assíncrono retorna um ID do job que você pode usar para verificar o status da raspagem em lote.

<div id="usage">
  ### Como usar
</div>

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

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

  job = firecrawl.batch_scrape([
      "https://firecrawl.dev",
      "https://docs.firecrawl.dev",
  ], formats=["markdown"], poll_interval=2, wait_timeout=120)

  print(job)
  ```

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

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

  const job = await firecrawl.batchScrape([
    'https://firecrawl.dev',
    'https://docs.firecrawl.dev',
  ], { options: { formats: ['markdown'] }, pollInterval: 2, timeout: 120 });

  console.log(job);
  ```

  ```bash cURL theme={null}
  curl -s -X POST "https://api.firecrawl.dev/v2/batch/scrape" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "urls": ["https://firecrawl.dev", "https://docs.firecrawl.dev"],
      "formats": ["markdown"]
    }'
  ```
</CodeGroup>

<div id="response">
  ### Resposta
</div>

Se você estiver usando os métodos síncronos dos SDKs, eles retornarão os resultados do job de scraping em lote. Caso contrário, será retornado um ID de job que você pode usar para verificar o status do scraping em lote.

<div id="synchronous">
  #### Sincronamente
</div>

```json Concluído theme={null}
{
  "status": "completed",
  "total": 36,
  "completed": 36,
  "creditsUsed": 36,
  "expiresAt": "2024-00-00T00:00:00.000Z",
  "next": "https://api.firecrawl.dev/v2/batch/scrape/123-456-789?skip=26",
  "data": [
    {
      "markdown": "[Página inicial da documentação do Firecrawl![logo 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 o seu site’."
        "ogLocaleAlternate": [],
        "statusCode": 200
      }
    },
    ...
  ]
}
```

<div id="asynchronous">
  #### Assíncrono
</div>

Você pode usar o ID da tarefa para verificar o status do batch scrape chamando o endpoint `/batch/scrape/{id}`. Este endpoint deve ser usado enquanto a tarefa ainda estiver em execução ou logo após sua conclusão, **pois as tarefas de batch scrape expiram após 24 horas**.

```json theme={null}
{
  "success": true,
  "id": "123-456-789",
  "url": "https://api.firecrawl.dev/v2/batch/scrape/123-456-789"
}
```

<div id="enhanced-mode">
  ## Modo Enhanced
</div>

Para sites complexos, o Firecrawl oferece um modo enhanced que aumenta as taxas de sucesso ao mesmo tempo em que preserva a privacidade.

Saiba mais sobre o [Modo Enhanced](/pt-BR/features/enhanced-mode).

<div id="zero-data-retention-zdr">
  ## Retenção zero de dados (ZDR)
</div>

O Firecrawl oferece Retenção zero de dados (ZDR) para equipes com requisitos rigorosos de tratamento de dados. Quando ativado, o Firecrawl não persistirá nenhum conteúdo de página nem dados extraídos além da duração da requisição.

Para ativar o ZDR, defina `zeroDataRetention: true` na sua requisição:

```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/scrape \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -d '{
    "url": "https://example.com",
    "formats": ["markdown"],
    "zeroDataRetention": true
  }'
```

O ZDR está disponível nos planos Enterprise e precisa ser habilitado para a sua equipe. Acesse [firecrawl.dev/enterprise](https://www.firecrawl.dev/enterprise) para começar.

O ZDR adiciona **1 crédito adicional por página** ao custo base de scraping.

<Note>
  Capturas de tela não estão disponíveis no modo ZDR. Como capturas de tela exigem envio para armazenamento persistente, elas são incompatíveis com a garantia do ZDR. Requisições que incluem `zeroDataRetention: true` e o formato `screenshot` retornarão um erro.
</Note>

> 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 obter instruções automatizadas de integração.