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

# Scrape

> Transformez n'importe quelle URL en données propres

Firecrawl convertit les pages web en markdown, idéal pour les applications LLM.

* Il gère les complexités : proxies, mise en cache, limites de débit, contenu bloqué par JS
* Prend en charge le contenu dynamique : sites web dynamiques, sites rendus par JS, PDF, images
* Produit du markdown propre, des données structurées, des captures d’écran ou du html.

Pour plus de détails, consultez la [référence de l’API Scrape point de terminaison](https://docs.firecrawl.dev/api-reference/endpoint/scrape).

<Card title="Essayez-le dans le Playground" icon="play" href="https://www.firecrawl.dev/playground?endpoint=scrape">
  Testez le scraping dans le Playground interactif — aucun code à écrire.
</Card>

<Note>Si une requête échoue, consultez [Erreurs](/fr/api-reference/errors) pour accéder au catalogue complet des codes d’erreur, de leurs causes, des correctifs et des conseils de nouvelle tentative.</Note>

<div id="scraping-a-url-with-firecrawl">
  ## Extraire le contenu d’une URL avec Firecrawl
</div>

<div id="scrape-endpoint">
  ### point de terminaison /scrape
</div>

Utilisé pour scraper une URL et en récupérer le contenu.

<div id="installation">
  ### Installation
</div>

<CodeGroup>
  ```python Python theme={null}
  # pip install firecrawl-py

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

  ```js Node theme={null}
  // npm install firecrawl

  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",
  });
  ```

  ```bash CLI theme={null}
  # Installer globalement avec npm
  npm install -g firecrawl

  # Authentification (configuration unique)
  firecrawl login
  ```
</CodeGroup>

### Utilisation

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

  # Extraire le contenu d'un site :
  doc = firecrawl.scrape("https://firecrawl.dev", formats=["markdown", "html"])
  print(doc)
  ```

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

  // Récupérer le contenu d'un site :
  const doc = await firecrawl.scrape('https://firecrawl.dev', { formats: ['markdown', 'html'] });
  console.log(doc);
  ```

  ```bash cURL theme={null}
  # Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
  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

  # Avec plusieurs formats (renvoie du JSON)
  firecrawl https://firecrawl.dev --format markdown,html,links --pretty
  ```
</CodeGroup>

Pour plus d’informations sur les paramètres, consultez la [référence de l’API](https://docs.firecrawl.dev/api-reference/endpoint/scrape).

<Tip>
  **PDF et documents :** `/scrape` détecte automatiquement les PDF, DOCX et d’autres types de documents à partir des URL. Fournissez une URL de PDF de la même manière que pour n’importe quelle page web -- Firecrawl l’analyse et renvoie un markdown propre. Pour les fichiers locaux qui ne sont pas accessibles par URL, utilisez plutôt [`/parse`](/fr/features/parse).

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

<Info>
  Chaque opération de `scrape` consomme 1 crédit. Des crédits supplémentaires sont facturés pour certaines options : le mode JSON coûte 4 crédits supplémentaires par page, les formats question et highlights coûtent 4 crédits supplémentaires par page et par format, le proxy avancé coûte 4 crédits supplémentaires par page, le masquage des PII coûte 4 crédits supplémentaires par page, le traitement des PDF coûte 1 crédit par page de PDF, et l’extraction audio ou vidéo coûte 4 crédits supplémentaires par page.
</Info>

<div id="response">
  ### Réponse
</div>

Les SDK renvoient directement l’objet de données. cURL renvoie la charge utile exactement comme ci-dessous.

```json theme={null}
{
  "success": true,
  "data" : {
    "markdown": "Launch Week I est là ! [Découvrez notre sortie du Jour 2 🚀](https://www.firecrawl.dev/blog/launch-week-i-day-2-doubled-rate-limits)[💥 2 mois offerts...",
    "html": "<!DOCTYPE html><html lang=\"en\" class=\"light\" style=\"color-scheme: light;\"><body class=\"__variable_36bd41 __variable_d7dc5d font-inter ...",
    "metadata": {
      "title": "Accueil - Firecrawl",
      "description": "Firecrawl explore et convertit n'importe quel site web en markdown propre.",
      "language": "en",
      "keywords": "Firecrawl,Markdown,Données,Mendable,Langchain",
      "robots": "follow, index",
      "ogTitle": "Firecrawl",
      "ogDescription": "Transformez n'importe quel site web en données prêtes pour les 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">
  ## Formats de scraping
</div>

Vous pouvez désormais choisir les formats de votre sortie. Vous pouvez spécifier plusieurs formats de sortie. Les formats pris en charge sont :

* Markdown (`markdown`)
* Résumé (`summary`)
* HTML (`html`) - version nettoyée du HTML de la page
* HTML brut (`rawHtml`) - HTML non modifié tel que reçu depuis la page
* Capture d’écran (`screenshot`, avec des options comme `fullPage`, `quality`, `viewport`) — les URL de capture d’écran expirent après 24 heures
* Liens (`links`)
* JSON (`json`) - sortie structurée
* Images (`images`) - extrait toutes les URL d’images de la page
* Branding (`branding`) - extrait l’identité de marque et le design system
* Produit (`product`) - extrait un produit structuré (titre, prix, disponibilité, variantes) à partir de pages produit
* Audio (`audio`) - extrait l’audio MP3 à partir d’URL vidéo prises en charge, par ex. YouTube (retourne une URL GCS signée, expire après 1 heure)
* Vidéo (`video`) - extrait la vidéo de meilleure qualité à partir d’URL vidéo prises en charge, par ex. YouTube (retourne une URL GCS signée, expire après 1 heure)
* Requête (`query`, avec `prompt` et `mode` facultatif) - posez une question en langage naturel sur la page ; la réponse est renvoyée dans le champ `answer`

Les clés de sortie correspondront au format que vous choisissez.

<div id="extract-structured-data">
  ## Extraire des données structurées
</div>

<div id="scrape-with-json-endpoint">
  ### Point de terminaison /scrape (avec json)
</div>

Permet d’extraire des données structurées à partir de pages scrappées.

<Tip>
  Vous extrayez des produits ? Pour les pages produit, le format [`product`](#extract-product-data) renvoie des champs de produit structurés (titre, prix, disponibilité, variantes) de manière déterministe — sans appel à un LLM ni schéma à définir. Utilisez `json` lorsque vous avez besoin de champs personnalisés ou pour des pages qui ne sont pas des pages produit.
</Tip>

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

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

  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({
    // Aucune clé API requise pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
    // apiKey: "fc-YOUR_API_KEY",
  });

  // Définir le schéma pour extraire les contenus
  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}
  # Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer VOTRE_CLÉ_API" pour des limites de débit plus élevées :
  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>

Résultat :

```json JSON theme={null}
{
    "success": true,
    "data": {
      "json": {
        "company_mission": "Scraping et extraction de données web propulsés par l’IA",
        "supports_sso": true,
        "is_open_source": true,
        "is_in_yc": true
      },
      "metadata": {
        "title": "Firecrawl",
        "description": "Scraping et extraction de données web propulsés par l’IA",
        "robots": "suivre, indexer",
        "ogTitle": "Firecrawl",
        "ogDescription": "Scraping et extraction de données web propulsés par l’IA",
        "ogUrl": "https://firecrawl.dev/",
        "ogImage": "https://firecrawl.dev/og.png",
        "ogLocaleAlternate": [],
        "ogSiteName": "Firecrawl"
        "sourceURL": "https://firecrawl.dev/"
      },
    }
}
```

<div id="extracting-without-schema">
  ### Extraction sans schéma
</div>

Vous pouvez désormais extraire sans schéma en passant simplement un `prompt` au point de terminaison. Le LLM choisit la structure des données.

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

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

  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({
    // Aucune clé API requise pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
    // apiKey: "fc-VOTRE_CLÉ_API",
  });

  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}
  # Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer VOTRE_CLÉ_API" pour des limites de débit plus élevées :
  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>

Résultat :

```json JSON theme={null}
{
    "success": true,
    "data": {
      "json": {
        "company_mission": "Collecte et extraction de données web propulsées par l’IA",
      },
      "metadata": {
        "title": "Firecrawl",
        "description": "Collecte et extraction de données web propulsées par l’IA",
        "robots": "follow, index",
        "ogTitle": "Firecrawl",
        "ogDescription": "Collecte et extraction de données web propulsées par l’IA",
        "ogUrl": "https://firecrawl.dev/",
        "ogImage": "https://firecrawl.dev/og.png",
        "ogLocaleAlternate": [],
        "ogSiteName": "Firecrawl",
        "sourceURL": "https://firecrawl.dev/"
      },
    }
}
```

<div id="json-format-options">
  ### Options du format JSON
</div>

Lorsque vous utilisez le format `json`, passez un objet dans `formats` avec les paramètres suivants :

* `schema` : schéma JSON pour la sortie structurée.
* `prompt` : invite facultative pour orienter l’extraction lorsqu’un schéma est présent ou lorsque vous souhaitez un guidage léger.

<div id="extract-brand-identity">
  ## Extraire l’identité de marque
</div>

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

Le format « branding » extrait des informations complètes sur l’identité de marque à partir d’une page web, notamment les couleurs, les polices, la typographie, les espacements, les composants d’interface, et bien plus encore. C’est utile pour l’analyse de design systems, la veille de marque, ou la création d’outils qui doivent comprendre l’identité visuelle d’un site web.

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

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

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

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

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

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

  ```bash cURL theme={null}
  # Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
  curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
    -H "Content-Type: application/json" \
    -d '{
      "url": "https://firecrawl.dev",
      "formats": ["branding"]
    }'
  ```
</CodeGroup>

### Réponse

Le format d’habillage de marque retourne un objet `BrandingProfile` complet avec la structure suivante :

```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">
  ### Structure du profil de marque
</div>

L'objet `branding` contient les propriétés suivantes :

* `colorScheme` : Schéma de couleurs détecté (« light » ou « dark »)
* `logo` : URL du logo principal
* `colors` : Objet contenant les couleurs de la marque :
  * `primary`, `secondary`, `accent` : Couleurs principales de la marque
  * `background`, `textPrimary`, `textSecondary` : Couleurs de l’interface
  * `link`, `success`, `warning`, `error` : Couleurs sémantiques
* `fonts` : Tableau des familles de polices utilisées sur la page
* `typography` : Informations détaillées sur la typographie :
  * `fontFamilies` : Familles de polices principales, titres et code
  * `fontSizes` : Définitions des tailles pour les titres et le corps du texte
  * `fontWeights` : Définitions des graisses (light, regular, medium, bold)
  * `lineHeights` : Valeurs d’interlignage pour différents types de texte
* `spacing` : Informations sur les espacements et la mise en page :
  * `baseUnit` : Unité d’espacement de base en pixels
  * `borderRadius` : Rayon de bordure par défaut
  * `padding`, `margins` : Valeurs d’espacement
* `components` : Styles des composants d’interface :
  * `buttonPrimary`, `buttonSecondary` : Styles des boutons
  * `input` : Styles des champs de saisie
* `icons` : Informations sur le style des icônes
* `images` : Images de la marque (logo, favicon, og:image)
* `animations` : Paramètres d’animation et de transition
* `layout` : Configuration de la mise en page (grille, hauteurs d’en-tête/pied de page)
* `personality` : Traits de personnalité de la marque (ton, énergie, public cible)

<div id="combining-with-other-formats">
  ### Combiner avec d’autres formats
</div>

Vous pouvez combiner le format « branding » avec d’autres formats pour obtenir des données de page complètes :

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

  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({
    // Aucune clé API requise pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
    // apiKey: "fc-VOTRE-CLÉ-API",
  });

  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}
  # Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
  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">
  ## Extraire les données produit
</div>

Le format `product` extrait des données produit structurées **de façon déterministe** — le même type de sortie structurée que le [format `json`](#extract-structured-data), mais sans appel à un LLM ni schéma à définir, et spécialement conçu pour les pages produit. Si vous récupériez des champs produit avec un schéma `json`, utilisez plutôt `formats: ["product"]` — c'est plus rapide et moins coûteux, mais limité aux produits.

Il renvoie un objet `product` avec le titre, la marque, la catégorie, la description et les variantes — chaque variante incluant le prix, le prix d'origine, la disponibilité et les images — utile pour le suivi des prix, l'ingestion de catalogues ou les outils de comparaison de prix.

<div id="scrape-with-product-endpoint">
  ### point de terminaison /scrape (avec le paramètre product)
</div>

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

  firecrawl = Firecrawl(
    # Aucune clé API requise pour démarrer — ajoutez-en une pour augmenter les limites de débit :
    # 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({
    // Aucune clé API nécessaire pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
    // 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}
  # Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
  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>

### Réponse

Le format product renvoie un objet `product` avec la structure suivante :

```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">
  ### Structure de l’objet `product`
</div>

L’objet `product` contient les propriétés suivantes :

* `title` : Le nom du produit
* `brand` : La marque du produit (optionnel)
* `category` : La catégorie du produit (optionnel)
* `url` : L’URL canonique du produit
* `description` : La description du produit (optionnel)
* `variants` : Tableau des variantes du produit. La tarification, la disponibilité et les images sont définies sur chaque variante — un produit à SKU unique renvoie donc exactement une variante qui les contient. Chaque variante comprend :
  * `id`, `sku`, `title` : les identifiants et le libellé de la variante (tous optionnels)
  * `values` : une cartographie du nom d’option vers sa valeur, par ex. `{ "color": "Charcoal" }` (optionnel)
  * `price` : l’objet du prix actuel (optionnel) :
    * `amount` : La valeur numérique du prix
    * `currency` : Le code de devise, renvoyé uniquement lorsque la page le fournit (optionnel)
    * `formatted` : Le prix tel qu’affiché sur la page (optionnel)
  * `sale` : présent uniquement lorsque la variante est en promotion (optionnel). Contient :
    * `originalPrice` : Le prix d’origine (avant réduction), avec la même structure que `price`
  * `availability` : informations de disponibilité, toujours présentes sur une variante :
    * `inStock` : Indique si la variante est en stock
    * `text` : Le texte brut de disponibilité extrait de la page (optionnel)
  * `images` : tableau des images de la variante, chacune avec une `url` et un texte `alt` optionnel (optionnel)

<div id="how-product-extraction-works">
  ### Fonctionnement de l’extraction de produit
</div>

Le format `product` extrait le produit de manière déterministe à partir des données structurées présentes sur la page — aucun LLM n’intervient. Il fusionne plusieurs sources par ordre de priorité : **JSON-LD > microdonnées schema.org > RDFa > état embarqué (`__NEXT_DATA__`/Nuxt/Apollo/Redux/Remix) > `runParams` d’AliExpress > `dataLayer` de GA4 > OpenGraph/`<meta>`**. La fusion tient compte de l’identité, de sorte que des champs provenant de produits différents ne sont jamais combinés. La devise n’est indiquée que si la page la fournit.

<Note>
  L’extraction de produit fonctionne en mode fail-closed : les pages ambiguës ne renvoient aucun produit, et les sources moins fiables comme OpenGraph ne contribuent que lorsqu’un prix est présent. Sur une page sans produit extractible, la réponse omet l’objet `product` et ajoute un `warning` (par ex. "Aucun produit trouvé...").
</Note>

<Note>
  **Auto-hébergement :** le format `product` repose sur un service dédié d’extraction de produits. Sur Firecrawl Cloud, il fonctionne immédiatement. Si vous l’auto-hébergez, définissez `PRODUCT_EXTRACTION_SERVICE_URL` pour qu’il pointe vers ce service — lorsqu’il n’est pas défini, demander le format `product` renvoie un avertissement et aucun produit (selon le même principe que les formats audio/vidéo pour leur service).
</Note>

### Combiner avec d’autres formats

Vous pouvez combiner le format product avec d’autres formats pour obtenir des données complètes sur la page :

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

  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({
    // Aucune clé API requise pour démarrer — ajoutez-en une pour augmenter les limites de débit :
    // 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}
  # Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
  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">
  ## Extraction audio
</div>

Le format `audio` extrait l’audio de sites web pris en charge (par ex. YouTube) sous forme de fichiers MP3 et renvoie une URL signée de Google Cloud Storage. Cela est utile pour créer des pipelines de traitement audio, des services de transcription ou des outils de podcast.

<Info>
  L’extraction audio coûte 5 crédits par page (1 de base + 4 supplémentaires).
</Info>

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

  doc = firecrawl.scrape("https://www.youtube.com/watch?v=dQw4w9WgXcQ", formats=["audio"])
  print(doc.audio)  # URL GCS signée vers le fichier MP3
  ```

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

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

  console.log(doc.audio); // URL GCS signée vers le fichier MP3
  ```

  ```bash cURL theme={null}
  # Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
  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">
  ## Extraction vidéo
</div>

Le format `video` extrait la vidéo en meilleure qualité à partir des sites web pris en charge (par ex. YouTube) et renvoie une URL signée Google Cloud Storage. Cela permet de créer des pipelines de traitement vidéo, des outils de modération ou des workflows d’archivage multimédia.

<Info>
  L’extraction vidéo coûte 5 crédits par page (1 de base + 4 supplémentaires).
</Info>

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

  doc = firecrawl.scrape("https://www.youtube.com/watch?v=dQw4w9WgXcQ", formats=["video"])
  print(doc.video)  # URL GCS signée pointant vers le fichier vidéo
  ```

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

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

  console.log(doc.video); // URL GCS signée vers le fichier vidéo
  ```

  ```bash cURL theme={null}
  # Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
  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">
  ## Format `question`
</div>

Utilisez le format `question` pour poser une question en langage naturel à propos de la page. Firecrawl renvoie la réponse dans le champ `answer` de la réponse.

<Info>
  Le format `question` coûte 5 crédits par page (1 de base + 4 supplémentaires pour l’appel au LLM).
</Info>

Options dans l’objet de format :

* `question` (obligatoire pour `type: "question"`) : la question à laquelle répondre. Maximum : 10 000 caractères.

Vous pouvez combiner `question` avec d’autres formats — par exemple, demander `markdown` et `question` ensemble pour obtenir le contenu de la page et une réponse en un seul appel.

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

  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({
    // Aucune clé API requise pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
    // 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}
  # Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
  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>

Le format `question` est également disponible dans `/search` via `scrapeOptions`, ce qui exécute la même extraction sur chaque résultat de recherche.

<span id="highlights-format" />

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

Utilisez le format `highlights` pour trouver le texte source pertinent sur la page. Firecrawl renvoie le texte sélectionné dans le champ `highlights` de la réponse.

<Info>
  Le format `highlights` coûte 5 crédits par page (1 de base + 4 supplémentaires pour l’appel au LLM).
</Info>

Options dans l’objet de format :

* `query` (obligatoire pour `type: "highlights"`) : la requête de sélection du texte source. Maximum : 10 000 caractères.

Vous pouvez combiner `highlights` avec d’autres formats — par exemple, demander `markdown` et `highlights` ensemble pour obtenir le contenu de la page et le texte source en un seul appel.

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

  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({
    // Aucune clé API requise pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
    // 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}
  # Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
  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>

Le format `highlights` est également disponible dans `/search` via `scrapeOptions`, qui exécute la même extraction sur chaque résultat de recherche.

<div id="pii-redaction">
  ## Masquage des données personnelles identifiables
</div>

Définissez `redactPII: true` pour masquer les données personnelles identifiables dans le markdown renvoyé. Le champ `markdown` contient le résultat masqué.

Voir [Masquage des données personnelles identifiables](/fr/features/pii-redaction) pour des exemples avec le SDK, cURL, le CLI et MCP.

<div id="interacting-with-the-page-with-actions">
  ## Interagir avec la page à l’aide des actions
</div>

Firecrawl vous permet d’effectuer diverses actions sur une page web avant d’en extraire le contenu. C’est particulièrement utile pour interagir avec du contenu dynamique, naviguer entre les pages ou accéder à du contenu nécessitant une interaction de l’utilisateur.

<Tip>
  **Nous recommandons [Interact](/fr/features/interact) plutôt que les actions : notre nouvelle méthode, plus puissante, pour interagir avec les pages extraites.**

  Interact fonctionne comme une session de navigateur avec état qui reste active d’un appel à l’autre. Vous pouvez ainsi piloter une page étape par étape de l’une des deux façons suivantes :

  * **En langage naturel** pour des flux flexibles et non déterministes. Par ex. *« rechercher des “wireless headphones”, filtrer sur 4+ étoiles à moins de 200 \$, puis renvoyer les résultats »*.
  * **Avec du code Playwright ou agent-browser** pour des étapes déterministes. Par ex. `await page.click('#export')`.

  Interact prend également en charge les profils, les sessions persistantes et une vue navigateur en direct intégrable (avec un mode interactif dans lequel les utilisateurs finaux peuvent piloter eux-mêmes le navigateur).
</Tip>

Voici un exemple d’utilisation des actions pour accéder à google.com, rechercher Firecrawl, cliquer sur le premier résultat et prendre une capture d’écran.

Il est recommandé d’utiliser presque systématiquement l’action `wait` avant et après l’exécution d’autres actions afin de laisser suffisamment de temps au chargement de la page.

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

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

  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({
    // Aucune clé API requise pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
    // 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}
  # Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer VOTRE_CLÉ_API" pour des limites de débit plus élevées :
  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">
  ### Résultat
</div>

<CodeGroup>
  ```json JSON theme={null}
  {
    "success": true,
    "data": {
      "markdown": "Notre première Launch Week est terminée ! [Voir le récapitulatif 🚀](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": "Accueil - Firecrawl",
        "description": "Firecrawl explore et convertit n’importe quel site web en markdown propre.",
        "language": "en",
        "keywords": "Firecrawl,Markdown,Données,Mendable,LangChain",
        "robots": "index, follow",
        "ogTitle": "Firecrawl",
        "ogDescription": "Transformez n’importe quel site web en données prêtes pour les LLM.",
        "ogUrl": "https://www.firecrawl.dev/",
        "ogImage": "https://www.firecrawl.dev/og.png?123",
        "ogLocaleAlternate": [],
        "ogSiteName": "Firecrawl"
        "sourceURL": "http://google.com",
        "statusCode": 200
      }
    }
  }
  ```
</CodeGroup>

Pour les workflows qui nécessitent un contrôle plus avancé du navigateur après le scraping, comme des sessions authentifiées, une navigation en plusieurs étapes ou une vue en direct de la page, nous recommandons [Interact](/fr/features/interact) plutôt que d’étendre le tableau `actions`.

<div id="location-and-language">
  ## Localisation et langue
</div>

Indiquez le pays et les langues souhaitées pour obtenir un contenu pertinent selon votre zone cible et vos préférences linguistiques.

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

Lorsque vous renseignez les paramètres de localisation, Firecrawl utilisera, si possible, un proxy adapté et adoptera la langue et le fuseau horaire correspondants. Par défaut, la localisation est définie sur « US » si aucun paramètre n’est fourni.

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

Pour utiliser les paramètres de localisation et de langue, incluez l’objet `location` dans le corps de votre requête avec les propriétés suivantes :

* `country` : code pays ISO 3166-1 alpha-2 (p. ex. « US », « AU », « DE », « JP »). Par défaut : « US ».
* `languages` : un tableau des langues et paramètres régionaux préférés pour la requête, par ordre de priorité. Par défaut : la langue de la localisation spécifiée.

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

  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({
    // Aucune clé API requise pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
    // 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}
  # Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
  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>

Pour plus de détails sur les localisations prises en charge, consultez la [documentation sur les proxys](/fr/features/proxies).

<div id="caching-and-maxage">
  ## Mise en cache et maxAge
</div>

Pour accélérer les requêtes, Firecrawl renvoie par défaut les résultats depuis le cache lorsqu’une copie récente est disponible.

* **Fenêtre de fraîcheur par défaut** : `maxAge = 172800000` ms (2 jours). Si une page en cache est plus récente que ce délai, elle est renvoyée instantanément ; sinon, la page est scrapée puis mise en cache.
* **Performances** : cela peut accélérer les scrapes jusqu’à 5x lorsque les données n’ont pas besoin d’être ultra fraîches.
* **Toujours récupérer du contenu frais** : définissez `maxAge` à `0`. Notez que cela contourne entièrement le cache ; chaque requête passe donc par l’intégralité du pipeline de scraping, ce qui signifie qu’elle prendra plus de temps à aboutir et aura davantage de chances d’échouer. Utilisez une valeur de `maxAge` non nulle si une fraîcheur maximale à chaque requête n’est pas indispensable.
* **Éviter le stockage** : définissez `storeInCache` sur `false` si vous ne voulez pas que Firecrawl mette en cache/stocke les résultats pour cette requête.
* **Consultation du cache uniquement** : définissez `minAge` pour effectuer une consultation du cache uniquement sans déclencher de nouveau scrape. La valeur est exprimée en millisecondes et indique l’ancienneté minimale que doivent avoir les données en cache. Si aucune donnée en cache n’est trouvée, une erreur `404` avec le code `SCRAPE_NO_CACHED_DATA` est renvoyée. Définissez `minAge` à `1` pour accepter n’importe quelle donnée en cache, quel que soit son âge.
* **Suivi des modifications** : les requêtes qui incluent `changeTracking` contournent le cache ; `maxAge` est donc ignoré.
* **Crédits** : les résultats en cache coûtent toujours 1 crédit par page. La mise en cache améliore la vitesse, pas la consommation de crédits.

Exemple (forcer un contenu frais) :

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

Exemple (utiliser une fenêtre de cache de 10 minutes) :

<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">
  ## Extraction par lots de plusieurs URL
</div>

Vous pouvez désormais lancer l’extraction par lots de plusieurs URL simultanément. La fonction prend en arguments les URL de départ ainsi que des paramètres optionnels. L’argument params vous permet de définir des options supplémentaires pour la tâche d’extraction par lots, comme les formats de sortie.

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

C’est très proche du fonctionnement du point de terminaison `/crawl`. Il lance un job de scraping par lot et renvoie un ID de job pour en vérifier l’état.

Le SDK propose deux méthodes, synchrone et asynchrone. La méthode synchrone renvoie les résultats du job de scraping par lot, tandis que la méthode asynchrone renvoie un ID de job que vous pouvez utiliser pour en suivre l’état.

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

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

  firecrawl = Firecrawl(api_key="fc-YOUR-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">
  ### Réponse
</div>

Si vous utilisez les méthodes synchrones des SDK, elles renverront les résultats du travail de scraping par lot. Sinon, elles renverront un identifiant de travail que vous pourrez utiliser pour vérifier l’état du scraping par lot.

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

```json Terminé theme={null}
{
  "status": "terminée",
  "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": "[Page d’accueil de la documentation Firecrawl![logo clair](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": "Créer un « chat avec un site web » avec Groq Llama 3 | Firecrawl",
        "language": "en",
        "sourceURL": "https://docs.firecrawl.dev/learn/rag-llama3",
        "description": "Apprenez à utiliser Firecrawl, Groq Llama 3 et LangChain pour créer un bot « discuter avec votre site web ».",
        "ogLocaleAlternate": [],
        "statusCode": 200
      }
    },
    ...
  ]
}
```

<div id="asynchronous">
  #### Asynchrone
</div>

Vous pouvez ensuite utiliser l’ID de la tâche pour vérifier l’état du batch scrape en appelant le point de terminaison `/batch/scrape/{id}`. Ce point de terminaison est destiné à être utilisé pendant l’exécution de la tâche ou juste après son achèvement, **car les tâches de batch scrape expirent après 24 heures**.

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

<div id="enhanced-mode">
  ## Mode amélioré
</div>

Pour les sites web complexes, Firecrawl propose un mode amélioré qui offre de meilleurs taux de réussite tout en préservant la confidentialité.

En savoir plus sur le [Mode amélioré](/fr/features/enhanced-mode).

<div id="zero-data-retention-zdr">
  ## Rétention zéro des données (ZDR)
</div>

Firecrawl prend en charge la rétention zéro des données (ZDR) pour les équipes ayant des exigences strictes en matière de traitement des données. Lorsqu'elle est activée, Firecrawl ne conserve aucun contenu de page ni aucune donnée extraite au-delà de la durée de vie de la requête.

Pour activer ZDR, définissez `zeroDataRetention: true` dans votre requête :

```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
  }'
```

ZDR est disponible sur les offres Enterprise et doit être activé pour votre équipe. Rendez-vous sur [firecrawl.dev/enterprise](https://www.firecrawl.dev/enterprise) pour démarrer.

ZDR ajoute **1 crédit supplémentaire par page** en plus du coût de base du scrape.

<Note>
  Les captures d’écran ne sont pas disponibles en mode ZDR. Comme elles nécessitent un envoi vers un stockage persistant, elles sont incompatibles avec la garantie ZDR. Les requêtes qui incluent à la fois `zeroDataRetention: true` et un format `screenshot` renverront une erreur.
</Note>

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