# Scraping plus rapide (/fr/features/fast-scraping)

<!-- agent-signals: reading_time_min: 5 · est_tokens: 2242 · updated: 2026-07-30 -->
Related: [Recherche](/fr/features/search.md), [Extraits de recherche](/fr/features/search-highlights.md), [Index de recherche](/fr/features/research.md), [Scrape](/fr/features/scrape.md), [Scrape par lots](/fr/features/batch-scrape.md), [Mode JSON - Résultat structuré](/fr/features/llm-extract.md)

<div id="how-it-works">
  ## Fonctionnement [#fonctionnement]
</div>

Firecrawl met en cache les pages déjà extraites et, par défaut, renvoie une copie récente lorsqu’elle est disponible.

* **Actualisation par défaut** : `maxAge = 172800000` ms (2 jours). Si la copie en cache est plus récente, elle est renvoyée instantanément ; sinon, Firecrawl relance une extraction et met à jour le cache.
* **Forcer du frais** : Définissez `maxAge: 0` pour toujours ré-extraire. Notez que cela contourne entièrement le cache : chaque requête passe alors par l’intégralité du pipeline d’extraction, prendra plus de temps à se terminer et aura plus de risques d’échouer. Utilisez une valeur de `maxAge` non nulle si vous n’avez pas besoin de contenu en temps réel pour chaque requête.
* **Ignorer le cache** : Définissez `storeInCache: false` si vous ne souhaitez pas stocker les résultats d’une requête.

Obtenez vos résultats **jusqu’à 500 % plus rapidement** lorsque vous n’avez pas besoin des données les plus récentes. Contrôlez l’actualité via `maxAge` :

1. **Retour instantané** si une version récente de la page est disponible
2. **Extraction à jour** uniquement si notre version est plus ancienne que l’âge spécifié
3. **Gagnez du temps** — les résultats reviennent en millisecondes plutôt qu’en secondes

<div id="when-to-use-this">
  ## Quand l’utiliser [#quand-lutiliser]
</div>

**Idéal pour :**

* Documentation, articles, pages produit
* Traitements par lots
* Développement et tests
* Création de bases de connaissances

**À éviter :**

* Données en temps réel (cours boursiers, scores en direct, dernières actualités)
* Contenu fréquemment mis à jour
* Applications sensibles au facteur temps

<div id="usage">
  ## Utilisation [#utilisation]
</div>

Ajoutez `maxAge` à votre requête de scraping. Les valeurs sont en millisecondes (p. ex. `3600000` = 1 heure).

<CodeGroup>
  <CodeBlockTabs defaultValue="Python" groupId="javascript+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="JavaScript">
        JavaScript
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Python">
      ```python  
      from firecrawl import Firecrawl

      firecrawl = Firecrawl(
        # Aucune clé API requise pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
        # api_key="fc-YOUR_API_KEY",
      )

      # Utilisez les données mises en cache si elles datent de moins d'une heure (3 600 000 ms)
      # Cela peut être 5× plus rapide qu'un nouveau scraping !
      scrape_result = firecrawl.scrape(
          'https://firecrawl.dev',
          formats=['markdown'],
          max_age=3600000  # 1 hour in milliseconds
      )

      print(scrape_result.markdown)
      ```
    </CodeBlockTab>

    <CodeBlockTab value="JavaScript">
      ```javascript  
      import { Firecrawl } from 'firecrawl';

      const firecrawl = new Firecrawl({
        // Aucune clé API requise pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
        // apiKey: "fc-YOUR_API_KEY",
      });

      // Utilisez les données mises en cache si elles datent de moins d'1 heure (3 600 000 ms)
      // Cela peut être 5× plus rapide qu'un nouveau scraping !
      const scrapeResult = await firecrawl.scrape('https://firecrawl.dev', {
        formats: ['markdown'],
        maxAge: 3600000 // 1 heure en millisecondes
      });

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

<div id="common-maxage-values">
  ## Valeurs courantes de maxAge [#valeurs-courantes-de-maxage]
</div>

Voici quelques valeurs de référence utiles :

* **5 minutes** : `300000` — pour du contenu semi‑dynamique
* **1 heure** : `3600000` — pour du contenu mis à jour chaque heure
* **1 jour** : `86400000` — pour du contenu mis à jour quotidiennement
* **1 semaine** : `604800000` — pour du contenu relativement statique

<div id="performance-impact">
  ## Impact sur les performances [#impact-sur-les-performances]
</div>

Avec `maxAge` activé :

* **Des temps de réponse jusqu’à 500 % plus rapides** pour le contenu récent
* **Des résultats instantanés** plutôt que d’attendre de nouveaux scrapes

<div id="important-notes">
  ## Notes importantes [#notes-importantes]
</div>

* **Par défaut** : `maxAge` est `172800000` (2 jours)
* **Actualisé si nécessaire** : si nos données sont plus anciennes que `maxAge`, nous réexécutons automatiquement le scraping
* **Aucune donnée périmée** : vous ne recevrez jamais de données plus anciennes que le `maxAge` que vous avez spécifié
* **Crédits** : les résultats mis en cache coûtent toujours 1 crédit par page. La mise en cache améliore les performances et la latence, pas l'utilisation des crédits.

<div id="when-caching-is-bypassed">
  ### Cas où la mise en cache est ignorée [#cas-où-la-mise-en-cache-est-ignorée]
</div>

La mise en cache est automatiquement ignorée lorsque votre requête inclut l’un des éléments suivants :

* Des `headers` personnalisés
* Des `actions` (étapes d’automatisation du navigateur)
* Un `profile` de navigateur
* Le format `changeTracking`
* Des paramètres personnalisés de taille de fenêtre d’affichage ou de qualité pour `screenshot`

<div id="cache-hit-matching">
  ### Critères de correspondance d’un hit de cache [#critères-de-correspondance-dun-hit-de-cache]
</div>

Pour qu’il y ait un hit de cache, ces paramètres doivent correspondre exactement entre la requête d’origine et les requêtes suivantes : `url`, `mobile`, `location`, `waitFor`, `blockAds`, `screenshot` (activé/désactivé et pleine page), ainsi que le mode proxy furtif.

Vous pouvez vérifier le comportement du cache en consultant `metadata.cacheState` dans la réponse : sa valeur sera `"hit"` ou `"miss"`.

<div id="faster-crawling">
  ## Crawl plus rapide [#crawl-plus-rapide]
</div>

Les mêmes gains de vitesse s’appliquent lors du crawl de plusieurs pages. Utilisez `maxAge` dans `scrapeOptions` pour obtenir des résultats en cache pour les pages que nous avons vues récemment.

<CodeGroup>
  <CodeBlockTabs defaultValue="Python" groupId="curl+javascript+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="JavaScript">
        JavaScript
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="cURL">
        cURL
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Python">
      ```python  
      from firecrawl import Firecrawl
      from firecrawl.v2.types import ScrapeOptions

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

      # Crawl with cached scraping - 500% faster for pages we've seen recently
      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"Contenu : {page.markdown[:200]}...")
      ```
    </CodeBlockTab>

    <CodeBlockTab value="JavaScript">
      ```javascript  
      import { Firecrawl } from 'firecrawl';

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

      // Exploration avec scraping mis en cache — 500 % plus rapide pour les pages consultées récemment
      const crawlResult = await firecrawl.crawl('https://firecrawl.dev', {
        limit: 100,
        scrapeOptions: {
          formats: ['markdown'],
          maxAge: 3600000 // Utiliser les données en cache si elles ont moins d'une heure
        }
      });

      crawlResult.data.forEach(page => {
        console.log(`URL: ${page.metadata.sourceURL}`);
        console.log(`Content: ${page.markdown.substring(0, 200)}...`);
      });
      ```
    </CodeBlockTab>

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

Lors d’un crawl avec `maxAge`, chaque page de votre crawl bénéficiera d’une amélioration de vitesse de 500 % si nous disposons de données récentes en cache pour cette page.

Commencez à utiliser `maxAge` dès aujourd’hui pour des scrapes et des crawls nettement plus rapides !

> Êtes-vous un agent d’IA qui a besoin d’une clé API Firecrawl ? Consultez [firecrawl.dev/agent-onboarding/SKILL.md](https://www.firecrawl.dev/agent-onboarding/SKILL.md) pour obtenir des instructions d’intégration automatisée.