> ## 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. # Crawl > Crawler récursivement un site web et obtenir le contenu de chaque page Le crawl soumet une URL à Firecrawl, découvre récursivement chaque sous-page accessible et en extrait le contenu. Elle gère automatiquement les sitemaps, le rendu JavaScript et les limites de taux, en renvoyant du Markdown propre ou des données structurées pour chaque page. * Découvre les pages via le sitemap et le parcours récursif des liens * Prend en charge le filtrage des chemins, les limites de profondeur et le contrôle des sous-domaines et des liens externes * Renvoie les résultats via polling, WebSocket ou webhook Testez le crawl dans le Playground interactif — sans écrire de code.
## Installation
```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 ```
## Utilisation de base
Soumettez une tâche de crawl en appelant `POST /v2/crawl` avec une URL de départ. Le point de terminaison renvoie un ID de tâche que vous utilisez pour interroger les résultats. ```python Python theme={null} from firecrawl import Firecrawl firecrawl = Firecrawl(api_key="fc-VOTRE_CLÉ_API") docs = firecrawl.crawl(url="https://docs.firecrawl.dev", limit=10) print(docs) ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" }); const docs = await firecrawl.crawl('https://docs.firecrawl.dev', { limit: 10 }); console.log(docs); ``` ```bash cURL theme={null} curl -s -X POST "https://api.firecrawl.dev/v2/crawl" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "url": "https://docs.firecrawl.dev", "limit": 10 }' ``` ```bash CLI theme={null} # Start a crawl job (returns job ID) firecrawl crawl https://firecrawl.dev # Attend la fin avec affichage de la progression firecrawl crawl https://firecrawl.dev --wait --progress --limit 100 ``` Chaque page crawlée consomme 1 crédit. La valeur par défaut de `limit` pour le crawl est de 10 000 pages. Avant de démarrer, le point de terminaison de crawl vérifie que vos crédits restants suffisent à couvrir la valeur de `limit` — sinon, il renvoie une erreur **402 (Paiement requis)**. Définissez une valeur de `limit` plus basse pour correspondre à la taille de crawl prévue (par exemple `limit: 100`) afin d’éviter ce problème. Des crédits supplémentaires s’appliquent pour certaines options : le mode JSON coûte 4 crédits supplémentaires par page, le proxy amélioré coûte 4 crédits supplémentaires par page, et l’analyse des PDF coûte 1 crédit par page de PDF.
### Options de scrape
Toutes les options de l’[point de terminaison Scrape](/fr/api-reference/endpoint/scrape) sont disponibles dans crawl via `scrapeOptions` (JS) / `scrape_options` (Python). Elles s’appliquent à chaque page que le crawler extrait, y compris les formats, le proxy, la mise en cache, les actions, la localisation et les tags. ```python Python theme={null} from firecrawl import Firecrawl firecrawl = Firecrawl(api_key='fc-YOUR_API_KEY') # Crawl avec des options de scrape response = firecrawl.crawl('https://example.com', limit=100, scrape_options={ 'formats': [ 'markdown', { 'type': 'json', 'schema': { 'type': 'object', 'properties': { 'title': { 'type': 'string' } } } } ], 'proxy': 'auto', 'max_age': 600000, 'only_main_content': True } ) ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; const firecrawl = new Firecrawl({ apiKey: 'fc-YOUR_API_KEY' }); // Crawl avec des options de scrape const crawlResponse = await firecrawl.crawl('https://example.com', { limit: 100, scrapeOptions: { formats: [ 'markdown', { type: 'json', schema: { type: 'object', properties: { title: { type: 'string' } } }, }, ], proxy: 'auto', maxAge: 600000, onlyMainContent: true, }, }); ```
## Vérification du statut du crawl
Utilisez l’ID du job pour interroger l’état du crawl et récupérer les résultats. ```python Python theme={null} status = firecrawl.get_crawl_status("") print(status) ``` ```js Node theme={null} const status = await firecrawl.getCrawlStatus(""); console.log(status); ``` ```bash cURL theme={null} # Après avoir démarré un crawl, interrogez l’état via le jobId curl -s -X GET "https://api.firecrawl.dev/v2/crawl/" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" ``` ```bash CLI theme={null} # Vérifier le statut du crawl à l'aide de l'ID de tâche firecrawl crawl ``` Les résultats des jobs de crawl sont disponibles via l’API pendant 24 heures après leur achèvement. Après cette période, vous pouvez toujours consulter l’historique de vos crawls et leurs résultats dans les [journaux d’activité](https://www.firecrawl.dev/app/logs). Les pages dans le tableau `data` des résultats de crawl sont des pages que Firecrawl a extraites avec succès, même si le site cible a renvoyé une erreur HTTP comme 404. Le champ `metadata.statusCode` indique le code de statut HTTP renvoyé par le site cible. Pour récupérer les pages que Firecrawl lui‑même n’a pas réussi à extraire (par exemple en cas d’erreurs réseau, d’expirations de délai ou de blocages liés à robots.txt), utilisez l’endpoint dédié [Get Crawl Errors](/fr/api-reference/endpoint/crawl-get-errors) (`GET /crawl/{id}/errors`).
### Gestion des réponses
La réponse varie selon l’état du crawl. Pour les crawls non terminés ou les réponses volumineuses dépassant 10 Mo, un paramètre d’URL `next` est fourni. Vous devez appeler cette URL pour récupérer les 10 Mo de données suivants. Si le paramètre `next` est absent, cela indique la fin des données du crawl. Les paramètres `skip` et `next` ne sont pertinents que lors d’appels directs à l’API. Si vous utilisez le SDK, la pagination est gérée automatiquement et tous les résultats sont renvoyés en une seule fois. ```json Scraping theme={null} { "status": "scraping", "total": 36, "completed": 10, "creditsUsed": 10, "expiresAt": "2024-00-00T00:00:00.000Z", "next": "https://api.firecrawl.dev/v2/crawl/123-456-789?skip=10", "data": [ { "markdown": "[Page d’accueil de la documentation Firecrawl ![logo clair](https://mintlify.s3-us-west-1.amazonaws.com/firecrawl/logo/light.svg)!...", "html": "...", "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": "Découvrez comment utiliser Firecrawl, Groq Llama 3 et LangChain pour créer un bot de « chat avec votre site web ».", "ogLocaleAlternate": [], "statusCode": 200 } }, ... ] } ``` ```json Terminé theme={null} { "status": "terminé", "total": 36, "completed": 36, "creditsUsed": 36, "expiresAt": "2024-00-00T00:00:00.000Z", "next": "https://api.firecrawl.dev/v2/crawl/123-456-789?skip=26", "data": [ { "markdown": "[Firecrawl Docs home page![light logo](https://mintlify.s3-us-west-1.amazonaws.com/firecrawl/logo/light.svg)!...", "html": "...", "metadata": { "title": "Créer un « Chat with website » avec Groq Llama 3 | Firecrawl", "language": "en", "sourceURL": "https://docs.firecrawl.dev/learn/rag-llama3", "description": "Découvrez comment utiliser Firecrawl, Groq Llama 3 et LangChain pour créer un bot « Chat with your website ».", "ogLocaleAlternate": [], "statusCode": 200 } }, ... ] } ```
## Méthodes du SDK
Deux approches sont possibles pour utiliser crawl avec le SDK.
### Crawler puis attendre
La méthode `crawl` attend la fin du crawl et renvoie la réponse complète. Elle gère automatiquement la pagination. Cela est recommandé pour la plupart des cas d’usage. ```python Python theme={null} from firecrawl import Firecrawl from firecrawl.types import ScrapeOptions firecrawl = Firecrawl(api_key="fc-YOUR_API_KEY") # Crawler un site web : crawl_status = firecrawl.crawl( 'https://firecrawl.dev', limit=100, scrape_options=ScrapeOptions(formats=['markdown', 'html']), poll_interval=30 ) print(crawl_status) ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; const firecrawl = new Firecrawl({apiKey: "fc-YOUR_API_KEY"}); const crawlResponse = await firecrawl.crawl('https://firecrawl.dev', { limit: 100, scrapeOptions: { formats: ['markdown', 'html'], } }) console.log(crawlResponse) ``` La réponse inclut l’état du crawl et toutes les données extraites : ```bash Python theme={null} success=True status='completed' completed=100 total=100 creditsUsed=100 expiresAt=datetime.datetime(2025, 4, 23, 19, 21, 17, tzinfo=TzInfo(UTC)) next=None data=[ Document( markdown='[Jour 7 - Semaine de lancement III. Journée des intégrations — du 14 au 20 avril](...', metadata={ 'title': '15 projets de web scraping en Python : du niveau débutant à avancé', ... 'scrapeId': '97dcf796-c09b-43c9-b4f7-868a7a5af722', 'sourceURL': 'https://www.firecrawl.dev/blog/python-web-scraping-projects', 'url': 'https://www.firecrawl.dev/blog/python-web-scraping-projects', 'statusCode': 200 } ), ... ] ``` ```js Node theme={null} { success: true, status: "completed", completed: 100, total: 100, creditsUsed: 100, expiresAt: "2025-04-23T19:28:45.000Z", data: [ { markdown: "[Day 7 - Launch Week III.Integrations DayApril ...", html: ` ### Démarrer et vérifier plus tard La méthode `startCrawl` / `start_crawl` renvoie immédiatement un ID de crawl. Vous pouvez ensuite vérifier manuellement l’état. Utile pour les crawls de longue durée ou une logique de polling personnalisée. ```python Python theme={null} from firecrawl import Firecrawl firecrawl = Firecrawl(api_key="fc-YOUR-API-KEY") job = firecrawl.start_crawl(url="https://docs.firecrawl.dev", limit=10) print(job) # Vérifier l’état de l’exploration status = firecrawl.get_crawl_status(job.id) print(status) ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" }); const { id } = await firecrawl.startCrawl('https://docs.firecrawl.dev', { limit: 10 }); console.log(id); // Vérifier l'état du crawl const status = await firecrawl.getCrawlStatus(id); console.log(status); ``` ```bash cURL theme={null} curl -s -X POST "https://api.firecrawl.dev/v2/crawl" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "url": "https://docs.firecrawl.dev", "limit": 10 }' ``` ```bash CLI theme={null} # Démarrer le crawl (asynchrone, renvoie l'ID du job immédiatement) firecrawl crawl https://firecrawl.dev --limit 100 # Vérifier ensuite le statut plus tard firecrawl crawl ``` La réponse initiale renvoie l’ID du job : ```json theme={null} { "success": true, "id": "123-456-789", "url": "https://api.firecrawl.dev/v2/crawl/123-456-789" } ```
## Résultats en temps réel avec WebSocket
La méthode watcher fournit des mises à jour en temps réel à mesure que les pages sont crawlées. Lancez un crawl, puis abonnez-vous aux événements pour traiter immédiatement les données. ```python Python theme={null} import asyncio from firecrawl import AsyncFirecrawl async def main(): firecrawl = AsyncFirecrawl(api_key="fc-YOUR-API-KEY") # Démarrer d'abord un crawl started = await firecrawl.start_crawl("https://firecrawl.dev", limit=5) # Surveiller les mises à jour (instantanés) jusqu'au statut final async for snapshot in firecrawl.watcher(started.id, kind="crawl", poll_interval=2, timeout=120): if snapshot.status == "completed": print("DONE", snapshot.status) for doc in snapshot.data: print("DOC", doc.metadata.source_url if doc.metadata else None) elif snapshot.status == "failed": print("ERR", snapshot.status) else: print("STATUS", snapshot.status, snapshot.completed, "/", snapshot.total) asyncio.run(main()) ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; const firecrawl = new Firecrawl({ apiKey: 'fc-YOUR-API-KEY' }); // Lancer un crawl puis le suivre const { id } = await firecrawl.startCrawl('https://mendable.ai', { excludePaths: ['blog/*'], limit: 5, }); const watcher = firecrawl.watcher(id, { kind: 'crawl', pollInterval: 2, timeout: 120 }); watcher.on('document', (doc) => { console.log('DOC', doc); }); watcher.on('error', (err) => { console.error('ERR', err?.error || err); }); watcher.on('done', (state) => { console.log('DONE', state.status); }); // Démarrer l'observation (WS avec solution de repli HTTP) await watcher.start(); ```
## Webhooks
Vous pouvez configurer des webhooks pour recevoir des notifications en temps réel à mesure que votre crawl progresse. Cela vous permet de traiter les pages dès leur extraction, au lieu d’attendre la fin du crawl. ```bash cURL theme={null} curl -X POST https://api.firecrawl.dev/v2/crawl \ -H 'Content-Type: application/json' \ -H 'Authorization: Bearer YOUR_API_KEY' \ -d '{ "url": "https://docs.firecrawl.dev", "limit": 100, "webhook": { "url": "https://your-domain.com/webhook", "metadata": { "any_key": "any_value" }, "events": ["started", "page", "completed"] } }' ```
### Types d’événements
| Événement | Description | | ----------------- | -------------------------------------------------- | | `crawl.started` | Se déclenche au démarrage du crawl | | `crawl.page` | Se déclenche pour chaque page extraite avec succès | | `crawl.completed` | Se déclenche à la fin du crawl | | `crawl.failed` | Se déclenche si le crawl rencontre une erreur |
### Charge utile
```json theme={null} { "success": true, "type": "crawl.page", "id": "crawl-job-id", "data": [...], // Données de page pour les événements 'page' "metadata": {}, // Your custom metadata "error": null } ```
### Vérification des signatures de webhook
Chaque requête de webhook provenant de Firecrawl inclut un en-tête `X-Firecrawl-Signature` contenant une signature HMAC-SHA256. Vérifiez toujours cette signature pour vous assurer que le webhook est authentique et n'a pas été altéré. 1. Récupérez votre secret de webhook dans l'[onglet Advanced](https://www.firecrawl.dev/app/settings?tab=advanced) des paramètres de votre compte 2. Extrayez la signature de l'en-tête `X-Firecrawl-Signature` 3. Calculez le HMAC-SHA256 du corps brut de la requête à l'aide de votre secret 4. Comparez-le avec l'en-tête de signature en utilisant une fonction sécurisée contre les attaques par temporisation Ne traitez jamais un webhook sans vérifier d'abord sa signature. L'en-tête `X-Firecrawl-Signature` contient la signature au format : `sha256=abc123def456...` Pour des exemples d'implémentation complets en JavaScript et Python, consultez la [documentation sur la sécurité des webhooks](/fr/webhooks/security). Pour une documentation complète sur les webhooks, y compris les charges utiles d'événements détaillées, la structure des charges utiles, la configuration avancée et le dépannage, consultez la [documentation sur les webhooks](/fr/webhooks/overview).
## Référence de configuration
Ensemble complet des paramètres disponibles lors de l’envoi d’une tâche de crawl : | Paramètre | Type | Par défaut | Description | | ----------------------- | ---------- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `url` | `string` | (obligatoire) | URL de départ du crawl | | `limit` | `integer` | `10000` | Nombre maximal de pages à crawler | | `maxDiscoveryDepth` | `integer` | (aucun) | Profondeur maximale depuis l’URL racine en fonction des sauts de découverte de liens, et non du nombre de segments `/` dans l’URL. Chaque fois qu’une nouvelle URL est trouvée sur une page, une profondeur supérieure de 1 à celle de la page sur laquelle elle a été découverte lui est attribuée. Le site racine et les pages du sitemap ont une profondeur de découverte égale à 0. Les pages à la profondeur maximale sont tout de même extraites, mais les liens qu’elles contiennent ne sont pas suivis. | | `includePaths` | `string[]` | (aucun) | Expressions régulières sur le chemin de l’URL à inclure. Seuls les chemins correspondants sont crawlés. | | `excludePaths` | `string[]` | (aucun) | Expressions régulières sur le chemin de l’URL à exclure du crawl | | `regexOnFullURL` | `boolean` | `false` | Applique `includePaths`/`excludePaths` à l’URL complète (y compris les paramètres de requête), et pas seulement au chemin | | `crawlEntireDomain` | `boolean` | `false` | Suit les liens internes vers des URL sœurs ou parentes, et pas uniquement vers des chemins enfants | | `allowSubdomains` | `boolean` | `false` | Suit les liens vers les sous-domaines du domaine principal | | `allowExternalLinks` | `boolean` | `false` | Suit les liens vers des sites web externes | | `sitemap` | `string` | `"include"` | Gestion du sitemap : `"include"` (par défaut), `"skip"` ou `"only"` | | `ignoreQueryParameters` | `boolean` | `false` | Évite d’extraire plusieurs fois le même chemin avec des paramètres de requête différents | | `ignoreRobotsTxt` | `boolean` | `false` | Ignore les règles `robots.txt` du site web. **Enterprise uniquement** — contactez [support@firecrawl.com](mailto:support@firecrawl.com) pour l’activer. | | `robotsUserAgent` | `string` | (aucun) | Chaîne User-Agent personnalisée pour l’évaluation de `robots.txt`. Lorsqu’elle est définie, `robots.txt` est récupéré avec ce User-Agent et les règles sont évaluées par rapport à celui-ci au lieu de l’agent utilisateur par défaut. **Enterprise uniquement** — contactez [support@firecrawl.com](mailto:support@firecrawl.com) pour l’activer. | | `delay` | `number` | (aucun) | Délai, en secondes, entre les extractions afin de respecter les limites de débit. Le définir force la simultanéité à 1. | | `maxConcurrency` | `integer` | (aucun) | Nombre maximal d’extractions simultanées. Utilise par défaut la limite de simultanéité de votre équipe. | | `scrapeOptions` | `object` | (aucun) | Options appliquées à chaque page lors de l’extraction (formats, proxy, mise en cache, actions, etc.) | | `webhook` | `object` | (aucun) | Configuration du webhook pour les notifications en temps réel | | `prompt` | `string` | (aucun) | Prompt en langage naturel permettant de générer les options de crawl. Les paramètres explicitement définis remplacent les équivalents générés. |
## Détails importants
Par défaut, le crawl ignore les sous-liens qui ne dépendent pas de l’URL fournie. Par exemple, `website.com/other-parent/blog-1` ne sera pas renvoyé si vous lancez un crawl sur `website.com/blogs/`. Utilisez le paramètre `crawlEntireDomain` pour inclure les chemins frères et parents. Pour inclure des sous-domaines comme `blog.website.com` lors du crawl de `website.com`, utilisez le paramètre `allowSubdomains`. * **Découverte du sitemap** : Par défaut, le crawler inclut le sitemap du site pour découvrir les URL (`sitemap: "include"`). Si vous définissez `sitemap: "skip"`, seules les pages accessibles via des liens HTML depuis l’URL racine seront trouvées. Les ressources comme les PDF ou les pages profondément imbriquées listées dans le sitemap mais non directement liées en HTML ne seront pas découvertes. Pour une couverture maximale, conservez le paramètre par défaut. * **Utilisation des crédits** : Chaque page crawlée coûte 1 crédit. Le mode JSON ajoute 4 crédits par page, le proxy avancé ajoute 4 crédits par page, et l’analyse des PDF coûte 1 crédit par page de PDF. * **Expiration des résultats** : Les résultats des jobs restent disponibles via l’API pendant 24 heures après leur exécution. Passé ce délai, vous pouvez consulter les résultats dans les [journaux d’activité](https://www.firecrawl.dev/app/logs). * **Erreurs de crawl** : Le tableau `data` contient les pages que Firecrawl a réussi à extraire. Utilisez le point de terminaison [Get Crawl Errors](/fr/api-reference/endpoint/crawl-get-errors) pour récupérer les pages ayant échoué en raison d’erreurs réseau, de délais d’attente ou de blocages par robots.txt. * **Résultats non déterministes** : Les résultats du crawl peuvent varier d’une exécution à l’autre avec la même configuration. Les pages sont extraites de manière concurrente, donc l’ordre dans lequel les liens sont découverts dépend du timing réseau et des pages qui finissent de se charger en premier. Cela signifie que différentes branches d’un site peuvent être explorées à des degrés divers à l’approche de la limite de profondeur, en particulier avec des valeurs élevées de `maxDiscoveryDepth`. Pour obtenir des résultats plus déterministes, définissez `maxConcurrency` sur `1` ou utilisez `sitemap: "only"` si le site dispose d’un sitemap complet. > Ê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.