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

# Raspagem mais rápida

> Acelere suas raspagens em 500% com o parâmetro maxAge

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

O Firecrawl mantém em cache páginas já raspadas e, por padrão, retorna uma cópia recente quando disponível.

* **Frescura padrão**: `maxAge = 172800000` ms (2 dias). Se a cópia em cache for mais recente que isso, ela é retornada instantaneamente; caso contrário, o Firecrawl faz uma nova raspagem e atualiza o cache.
* **Forçar conteúdo novo**: Defina `maxAge: 0` para sempre raspar. Esteja ciente de que isso ignora completamente o cache, o que significa que toda requisição passa por todo o pipeline de raspagem, fazendo com que a requisição leve mais tempo para ser concluída e seja mais propensa a falhas. Use um `maxAge` diferente de zero se você não precisar de conteúdo em tempo real em toda requisição.
* **Pular cache**: Defina `storeInCache: false` se você não quiser armazenar os resultados de uma requisição.

Obtenha seus resultados **até 500% mais rápido** quando você não precisar dos dados absolutamente mais atuais. Controle a frescura via `maxAge`:

1. **Retorno instantâneo** se tivermos uma versão recente da página
2. **Raspar novamente** apenas se nossa versão for mais antiga do que a idade especificada por você
3. **Economize tempo** — os resultados chegam em milissegundos em vez de segundos

<div id="when-to-use-this">
  ## Quando usar
</div>

**Ideal para:**

* Documentação, artigos, páginas de produto
* Processamento em lote
* Desenvolvimento e testes
* Criação de bases de conhecimento

**Evite se precisar de:**

* Dados em tempo real (cotações, placares ao vivo, notícias de última hora)
* Conteúdo atualizado com frequência
* Aplicativos sensíveis ao tempo

<div id="usage">
  ## Uso
</div>

Adicione `maxAge` à sua solicitação de scrape. Os valores são em milissegundos (por exemplo, `3600000` = 1 hora).

<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",
  )

  # Use cached data if it's less than 1 hour old (3600000 ms)
  # This can be 500% faster than a fresh scrape!
  scrape_result = firecrawl.scrape(
      'https://firecrawl.dev',
      formats=['markdown'],
      max_age=3600000  # 1 hour in milliseconds
  )

  print(scrape_result.markdown)
  ```

  ```javascript JavaScript theme={null}
  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",
  });

  // Use o cache se ele tiver menos de 1 hora (3600000 ms)
  // Isso pode ser até 500% mais rápido do que uma raspagem do zero!
  const scrapeResult = await firecrawl.scrape('https://firecrawl.dev', {
    formats: ['markdown'],
    maxAge: 3600000 // 1 hora em milissegundos
  });

  console.log(scrapeResult.markdown);
  ```
</CodeGroup>

<div id="common-maxage-values">
  ## Valores comuns de maxAge
</div>

Aqui estão alguns valores de referência úteis:

* **5 minutos**: `300000` - Para conteúdo semidinâmico
* **1 hora**: `3600000` - Para conteúdo que é atualizado a cada hora
* **1 dia**: `86400000` - Para conteúdo atualizado diariamente
* **1 semana**: `604800000` - Para conteúdo relativamente estático

<div id="performance-impact">
  ## Impacto no desempenho
</div>

Com `maxAge` ativado:

* **Tempos de resposta 500% mais rápidos** para conteúdo recente
* **Resultados instantâneos** em vez de aguardar novas coletas

<div id="important-notes">
  ## Notas importantes
</div>

* **Padrão**: `maxAge` é `172800000` (2 dias)
* **Atual quando necessário**: Se nossos dados forem mais antigos que `maxAge`, fazemos uma nova coleta automaticamente
* **Sem dados desatualizados**: Você nunca receberá dados mais antigos do que o `maxAge` especificado
* **Créditos**: Resultados em cache ainda consomem 1 crédito por página. O cache melhora a velocidade e a latência, não o consumo de créditos.

<div id="when-caching-is-bypassed">
  ### Quando o cache é ignorado
</div>

O cache é automaticamente ignorado quando sua requisição inclui qualquer um dos seguintes itens:

* `headers` personalizados
* `actions` (etapas de automação do navegador)
* Um `profile` de navegador
* Formato `changeTracking`
* Configurações personalizadas de viewport ou de qualidade da `screenshot`

<div id="cache-hit-matching">
  ### Correspondência para acerto de cache
</div>

Para que haja um acerto de cache, estes parâmetros devem corresponder exatamente entre as requisições original e subsequentes: `url`, `mobile`, `location`, `waitFor`, `blockAds`, `screenshot` (captura de tela ativada/desativada e de página inteira) e o modo de proxy furtivo.

Você pode verificar o comportamento do cache consultando `metadata.cacheState` na resposta — será `"hit"` ou `"miss"`.

<div id="faster-crawling">
  ## Rastreamento mais rápido
</div>

Os mesmos ganhos de velocidade se aplicam ao rastrear várias páginas. Use `maxAge` em `scrapeOptions` para obter resultados em cache de páginas que vimos recentemente.

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl
  from firecrawl.v2.types import ScrapeOptions

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

  # Rastreamento com scraping em cache — 500% mais rápido para páginas acessadas recentemente
  crawl_result = firecrawl.crawl(
      'https://firecrawl.dev',
      limit=100,
      scrape_options=ScrapeOptions(
          formats=['markdown'],
          max_age=3600000  # Use cached data if less than 1 hour old
      )
  )

  for page in crawl_result.data:
      print(f"URL: {page.metadata.source_url}")
      print(f"Content: {page.markdown[:200]}...")
  ```

  ```javascript JavaScript theme={null}
  import { Firecrawl } from 'firecrawl';

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

  // Rastreamento com scraping em cache - 500% mais rápido para páginas acessadas recentemente
  const crawlResult = await firecrawl.crawl('https://firecrawl.dev', {
    limit: 100,
    scrapeOptions: {
      formats: ['markdown'],
      maxAge: 3600000 // Usar dados em cache se tiverem menos de 1 hora
    }
  });

  crawlResult.data.forEach(page => {
    console.log(`URL: ${page.metadata.sourceURL}`);
    console.log(`Conteúdo: ${page.markdown.substring(0, 200)}...`);
  });
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.firecrawl.dev/v2/crawl \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer fc-SUA_CHAVE_DE_API' \
    -d '{
      "url": "https://firecrawl.dev",
      "limit": 100,
      "scrapeOptions": {
        "formats": ["markdown"],
        "maxAge": 3600000
      }
    }'
  ```
</CodeGroup>

Ao rastrear com `maxAge`, cada página do seu rastreamento aproveitará a melhoria de velocidade de 500% se tivermos dados recentes em cache para essa página.

Comece a usar `maxAge` hoje para fazer scraping e rastreamentos muito mais rápidos!

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