# Parse (/fr/features/parse)

<!-- agent-signals: reading_time_min: 5 · est_tokens: 1937 · 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), [Scraping plus rapide](/fr/features/fast-scraping.md), [Scrape par lots](/fr/features/batch-scrape.md)

Le point de terminaison `/parse` convertit des documents locaux ou non accessibles au public en données propres, prêtes à être exploitées par des LLM. Envoyez le fichier via `multipart/form-data` et récupérez du Markdown, du JSON, du HTML, des liens, des images ou un résumé — tout en préservant l’ordre de lecture et les tableaux.

* Convertissez des PDF, DOCX, XLSX, HTML et bien plus en Markdown ou en JSON structuré
* Analyse jusqu’à **5x plus rapide** grâce à un moteur basé sur Rust
* Fichiers jusqu’à **50 MB** par requête
* Prise en charge de Zero Data Retention

<div id="when-to-use-parse">
  ## Quand utiliser `/parse` [#quand-utiliser-parse]
</div>

Utilisez `/parse` lorsque le document source est **un fichier local** ou **n'est pas accessible publiquement via une URL**. Si vous disposez d'une URL publique pointant vers un document, privilégiez [`/scrape`](/fr/features/scrape) — il détecte automatiquement le type de fichier à partir de l'extension ou du type de contenu, puis le traite de la même manière.

| Source                                                                  | Point de terminaison                                |
| ----------------------------------------------------------------------- | --------------------------------------------------- |
| URL publique vers un document (p. ex. `https://example.com/report.pdf`) | [`POST /scrape`](/fr/api-reference/endpoint/scrape) |
| Fichier local ou octets non publics (PDF, DOCX, XLSX, HTML, ...)        | [`POST /parse`](/fr/api-reference/endpoint/parse)   |

<Tip>
  **Vous utilisez Firecrawl via MCP ?** Utilisez `firecrawl_parse` pour les fichiers locaux. Le MCP local peut lire le fichier directement lorsqu'il est configuré avec `FIRECRAWL_API_URL`. Le MCP hébergé à distance renvoie d'abord une commande d'upload temporaire, puis traite l'`uploadRef` renvoyé. Les URL publiques de documents doivent toujours utiliser `/scrape`.
</Tip>

<Tip>
  **Vous avez une URL publique vers un PDF ?** Utilisez plutôt `/scrape` -- il détecte automatiquement les types de documents et renvoie un markdown propre. Pas besoin d'une bibliothèque PDF distincte.

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

<div id="parsing">
  ## Parsing [#parsing]
</div>

<div id="parse-endpoint">
  ### Point de terminaison /parse [#point-de-terminaison-parse]
</div>

Permet de téléverser un fichier et d’obtenir son contenu analysé. La requête est au format `multipart/form-data`, avec une partie `file` requise et une partie JSON `options` facultative.

**Extensions prises en charge :** `.html`, `.htm`, `.pdf`, `.docx`, `.doc`, `.odt`, `.rtf`, `.xlsx`, `.xls`.

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

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

      <CodeBlockTabsTrigger value="Node">
        Node
      </CodeBlockTabsTrigger>

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

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

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

      doc = firecrawl.parse("./report.pdf")

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

    <CodeBlockTab value="Node">
      ```javascript  
      import { Firecrawl } from "firecrawl";
      import fs from "node:fs";

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

      const doc = await firecrawl.parse({
        data: fs.readFileSync("./report.pdf"),
        filename: "report.pdf",
      });

      console.log(doc.markdown);
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      curl -X POST https://api.firecrawl.dev/v2/parse \
        -H 'Authorization: Bearer YOUR_API_KEY' \
        -F 'file=@./report.pdf' \
        -F 'options={"formats":["markdown"]};type=application/json'
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

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

Les SDK renvoient directement l’objet document. cURL renvoie le payload JSON.

```json
{
  "success": true,
  "data": {
    "markdown": "# Annual Report\n\n...",
    "metadata": {
      "title": "Annual Report",
      "numPages": 42,
      "totalPages": 42,
      "sourceFile": "report.pdf"
    }
  }
}
```

<Note>
  `numPages` est le nombre de pages réellement analysées ; `totalPages` correspond au nombre
  réel de pages du document. Ils correspondent sauf si `maxPages` a tronqué le résultat — p. ex. l’analyse
  d’un PDF de 100 pages avec `maxPages: 10` renvoie `numPages: 10` et `totalPages: 100`, donc
  `totalPages > numPages` indique que la sortie a été tronquée. `totalPages` est omis
  lorsque le nombre de pages ne peut pas être déterminé.
</Note>

<div id="options">
  ## Options [#options]
</div>

`/parse` accepte un sous-ensemble des options de scrape dans le champ `options`. Paramètres courants :

* `formats` : tableau de formats de sortie. Valeur par défaut : `["markdown"]`. Pris en charge : `markdown`, `html`, `rawHtml`, `links`, `images`, `summary` et `json` (avec un schéma ou un prompt).
* `onlyMainContent` : renvoie uniquement le contenu principal du document. Valeur par défaut : `true`.
* `includeTags` / `excludeTags` : inclusion ou exclusion au niveau des balises (éléments HTML).
* `redactPII` : masque les informations personnelles identifiables dans le markdown renvoyé.
* `timeout` : délai d’expiration de la requête en millisecondes. Valeur par défaut : `30000`, maximum `300000`.
* `parsers` : paramètres du parseur de fichiers. Pour les PDF, définissez `{ "type": "pdf", "mode": "fast" | "auto" | "ocr", "maxPages": <int> }`.

<Note>
  `/parse` ne prend pas en charge les options réservées au navigateur comme `actions`, `waitFor`, `location`, `mobile` ou le suivi des modifications.
</Note>

<div id="pdf-parser-modes">
  ### Modes du parseur PDF [#modes-du-parseur-pdf]
</div>

```bash title="cURL"
curl -X POST https://api.firecrawl.dev/v2/parse \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -F 'file=@./scan.pdf' \
  -F 'options={"parsers":[{"type":"pdf","mode":"ocr","maxPages":50}]};type=application/json'
```

* `fast` : extraction de texte uniquement, option la plus rapide.
* `auto` (par défaut) : priorité au texte avec recours à l’OCR pour les pages composées uniquement d’images.
* `ocr` : OCR sur chaque page — à utiliser pour les documents numérisés.

<div id="structured-json-output">
  ### Sortie JSON structurée [#sortie-json-structurée]
</div>

Fournissez un schéma JSON ou un prompt pour extraire des données structurées directement du document :

```bash title="cURL"
curl -X POST https://api.firecrawl.dev/v2/parse \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -F 'file=@./invoice.pdf' \
  -F 'options={"formats":[{"type":"json","schema":{"type":"object","properties":{"total":{"type":"number"},"vendor":{"type":"string"}}}}]};type=application/json'
```

<div id="considerations">
  ## Considérations [#considérations]
</div>

* La taille maximale de fichier est de **50 MB** par requête.
* L’analyse de PDF très volumineux ou numérisés en mode `ocr` peut prendre plus de temps — augmentez `timeout` ou utilisez `maxPages` pour limiter le traitement.
* Pour des lots de fichiers, appelez `/parse` pour chaque fichier en parallèle ; il n’existe pas d’option de téléversement par lot.

> Êtes-vous un agent 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.