> ## Documentation Index > Fetch the complete documentation index at: https://student-213fb9fc.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Exploration > Firecrawl peut parcourir de manière récursive les sous-domaines d'une URL et en extraire le contenu Firecrawl explore efficacement les sites web pour extraire des données complètes tout en gérant une infrastructure web complexe. Le processus : 1. **Analyse d’URL :** Parcourt le sitemap et le site pour identifier les liens 2. **Parcours :** Suit les liens de manière récursive afin de trouver toutes les sous-pages 3. **Scraping :** Extrait le contenu de chaque page, en gérant le JavaScript et les limites de taux 4. **Résultats :** Convertit les données en Markdown propre ou en format structuré Cela garantit une collecte de données exhaustive à partir de n’importe quelle URL de départ. Testez le crawl dans le Playground interactif — sans écrire de code.
## Crawl
### /crawl endpoint
Permet d’explorer une URL et toutes les sous-pages accessibles. Soumet un travail d’exploration et renvoie un ID de tâche pour suivre l’état de l’exploration. Par défaut, Crawl ignore les sous-liens d’une page s’ils ne sont pas des « enfants » de l’URL fournie. Ainsi, website.com/other-parent/blog-1 ne sera pas renvoyé si vous explorez website.com/blogs/. Si vous souhaitez website.com/other-parent/blog-1, utilisez le paramètre `crawlEntireDomain`. Pour explorer des sous-domaines comme blog.website.com lors de l’exploration de website.com, utilisez le paramètre `allowSubdomains`. Par défaut, le crawler inclut le sitemap du site pour découvrir des URL (`sitemap: "include"`). Si vous définissez `sitemap: "skip"`, le crawler ne trouvera que les pages accessibles via des liens HTML à partir de l’URL racine. Les ressources comme les PDF ou les pages très profondément imbriquées qui sont listées dans le sitemap mais non liées directement depuis une page HTML seront ignorées. Pour une couverture maximale, conservez le paramètre par défaut `sitemap: "include"`.
### Installation
```python Python theme={null} # pip install firecrawl-py from firecrawl import Firecrawl firecrawl = Firecrawl(api_key="fc-VOTRE-CLE-API") ``` ```js Node theme={null} # npm install @mendable/firecrawl-js import Firecrawl from '@mendable/firecrawl-js'; const firecrawl = new Firecrawl({ apiKey: "fc-VOTRE-CLÉ-API" }); ``` ```bash CLI theme={null} # Installer globalement avec npm npm install -g firecrawl # Authentification (configuration unique) firecrawl login ```
### Utilisation
```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.js theme={null} import Firecrawl from '@mendable/firecrawl-js'; const firecrawl = new Firecrawl({ apiKey: "fc-VOTRE_CLE_API" }); 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 explorée consomme 1 crédit. La valeur par défaut de `limit` pour l’exploration est de 10 000 pages — définissez une valeur de `limit` plus basse pour contrôler l’utilisation des crédits (par exemple `limit: 100`). 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 dans crawl
Toutes les options de l’endpoint Scrape sont disponibles dans Crawl via `scrapeOptions` (JS) / `scrape_options` (Python). Elles s’appliquent à chaque page que le crawler extrait : formats, proxy, mise en cache, actions, localisation, tags, etc. Consultez la liste complète dans la [référence de l’API Scrape](https://docs.firecrawl.dev/api-reference/endpoint/scrape). ```js Node theme={null} import Firecrawl from '@mendable/firecrawl-js'; 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, }, }); ``` ```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 } ) ```
### Réponse de l’API
Si vous utilisez cURL ou la méthode starter, cela renverra un `ID` pour vérifier l’état du crawl. Si vous utilisez le SDK, consultez les méthodes ci-dessous pour comprendre le comportement « waiter » vs « starter ». ```json theme={null} { "success": true, "id": "123-456-789", "url": "https://api.firecrawl.dev/v2/crawl/123-456-789" } ```
### Vérifier un job de crawl
Permet de consulter l’état d’un job de crawl et d’en récupérer le résultat. 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`). ```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 ```
#### 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. Le paramètre skip définit le nombre maximal de résultats renvoyés pour chaque segment de résultats. Les paramètres skip et next ne sont pertinents que lors d’appels directs à l’API. Si vous utilisez le SDK, nous gérons cela pour vous et renverrons tous les résultats 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 le SDK : 1. **Crawler puis attendre** (`crawl`) : * Attend la fin du crawl et renvoie la réponse complète * Gère automatiquement la pagination * 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.js theme={null} import Firecrawl from '@mendable/firecrawl-js'; 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 } ), ... ] ``` ```json 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: ` ```
## WebSocket de crawl
La méthode WebSocket de Firecrawl, « Crawl URL and Watch », permet l’extraction et la supervision des données en temps réel. Lancez un crawl à partir d’une URL et personnalisez-le avec des options comme des limites de pages, des domaines autorisés et des formats de sortie — idéal pour le traitement immédiat des 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 '@mendable/firecrawl-js'; 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('TERMINÉ', state.status); }); // Démarrer l’observation (WS avec solution de repli HTTP) await watcher.start(); ```
## Webhook de crawl
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"] } }' ```
### Référence rapide
**Types d’événements :** * `crawl.started` - Au début de l’exploration * `crawl.page` - Pour chaque page extraite avec succès * `crawl.completed` - À la fin de l’exploration * `crawl.failed` - Si l’exploration échoue **Charge utile de base :** ```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 } ```
### Sécurité : 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é. **Fonctionnement :** 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).
### Documentation complète
Pour une documentation complète des webhooks, incluant le détail des payloads d’événements, la structure des payloads, la configuration avancée et le dépannage, consultez la [documentation Webhooks](/fr/webhooks/overview).