> ## 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.
# Serveur MCP Firecrawl
> Utilisez l’API Firecrawl via le Model Context Protocol
Une implémentation de serveur Model Context Protocol (MCP) intégrant [Firecrawl](https://github.com/firecrawl/firecrawl) pour la recherche, le scraping et l’interaction avec le web. Notre serveur MCP est open source et disponible sur [GitHub](https://github.com/firecrawl/firecrawl-mcp-server).
## Fonctionnalités
* Recherche sur le web et récupération du contenu complet des pages
* Extraction de n’importe quelle URL en données structurées propres
* Analyse de fichiers locaux tels que des PDF, DOCX, XLSX et HTML
* Interaction avec les pages — cliquer, naviguer et effectuer des actions
* Recherche approfondie avec agent autonome
* Prise en charge du cloud et de l’auto‑hébergement
* Prise en charge de l’HTTP en streaming
## Installation
Vous pouvez utiliser notre URL hébergée ou exécuter le serveur en local. Récupérez votre clé API sur [https://firecrawl.dev/app/api-keys](https://www.firecrawl.dev/app/api-keys)
**Pas de clé API ?** Connectez-vous à `https://mcp.firecrawl.dev/v2/mcp` pour utiliser l’offre gratuite distante sans clé. Ce service est gratuit et soumis à une limite de débit par IP ; consultez [Limite de débit](/fr/rate-limits#keyless-no-api-key) pour connaître la liste actuelle des outils sans clé. Définissez `FIRECRAWL_API_KEY` pour activer tous les outils MCP ainsi que des limites plus élevées.
### URL hébergée à distance
Connectez-vous sans clé API pour démarrer avec l’offre Free sans clé à distance (avec limitation de débit par IP ; consultez [Limites de débit](/fr/rate-limits#keyless-no-api-key) pour la liste actuelle des outils) :
```bash theme={null}
https://mcp.firecrawl.dev/v2/mcp
```
Avec une clé API, envoyez-la dans l’en-tête `Authorization` pour déverrouiller tous les outils et bénéficier de limites plus élevées :
```json theme={null}
{
"mcpServers": {
"firecrawl": {
"url": "https://mcp.firecrawl.dev/v2/mcp",
"headers": {
"Authorization": "Bearer fc-YOUR_API_KEY"
}
}
}
}
```
### Exécution via npx
```bash theme={null}
env FIRECRAWL_API_KEY=fc-YOUR_API_KEY npx -y firecrawl-mcp
```
### Installation manuelle
```bash theme={null}
npm install -g firecrawl-mcp
```
### Utilisation avec Cursor
Installez le serveur hébergé en mode sans clé en un clic (aucune clé API requise) :
Ou ajoutez-le manuellement à `~/.cursor/mcp.json` :
```json theme={null}
{
"mcpServers": {
"firecrawl": {
"url": "https://mcp.firecrawl.dev/v2/mcp"
}
}
}
```
#### Exécution locale avec une clé API
Remarque : nécessite Cursor version 0.45.6+
Pour des instructions de configuration à jour, consultez la documentation officielle de Cursor sur la configuration des serveurs MCP :
[Guide de configuration du serveur MCP de Cursor](https://cursor.com/docs/context/mcp)
Pour configurer Firecrawl MCP dans Cursor **v0.48.6**
1. Ouvrez les paramètres de Cursor
2. Allez dans Features > MCP Servers
3. Cliquez sur "+ Add new global MCP server"
4. Saisissez le code suivant :
```json theme={null}
{
"mcpServers": {
"firecrawl-mcp": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "YOUR-API-KEY"
}
}
}
}
```
Pour configurer Firecrawl MCP dans Cursor **v0.45.6**
1. Ouvrez les paramètres de Cursor
2. Allez dans Features > MCP Servers
3. Cliquez sur "+ Add New MCP Server"
4. Renseignez les éléments suivants :
* Name: "firecrawl-mcp" (ou le nom de votre choix)
* Type: "command"
* Command: `env FIRECRAWL_API_KEY=your-api-key npx -y firecrawl-mcp`
> Si vous utilisez Windows et rencontrez des problèmes, essayez `cmd /c "set FIRECRAWL_API_KEY=your-api-key && npx -y firecrawl-mcp"`
Remplacez `your-api-key` par votre clé API Firecrawl. Si vous n'en avez pas encore, créez un compte et récupérez-la via [https://www.firecrawl.dev/app/api-keys](https://www.firecrawl.dev/app/api-keys)
Après l’ajout, actualisez la liste des serveurs MCP pour voir les nouveaux outils. Le Composer Agent utilisera automatiquement Firecrawl MCP lorsque c’est pertinent, mais vous pouvez aussi le demander explicitement en décrivant vos besoins en données web. Accédez au Composer via Command+L (Mac), sélectionnez « Agent » à côté du bouton d’envoi, puis saisissez votre requête.
### Exécuter sur Windsurf
Ajoutez ceci à votre `./codeium/windsurf/model_config.json` :
```json theme={null}
{
"mcpServers": {
"mcp-server-firecrawl": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "VOTRE_API_KEY"
}
}
}
}
```
### Exécution avec le mode HTTP en streaming
Pour exécuter le serveur localement en utilisant le transport HTTP en streaming au lieu du transport `stdio` par défaut :
```bash theme={null}
env HTTP_STREAMABLE_SERVER=true FIRECRAWL_API_KEY=fc-YOUR_API_KEY npx -y firecrawl-mcp
```
Utilisez l’URL suivante en local : [http://localhost:3000/v2/mcp](http://localhost:3000/v2/mcp), ou la version hébergée [https://mcp.firecrawl.dev/v2/mcp](https://mcp.firecrawl.dev/v2/mcp)
### Installation via Smithery (ancienne méthode)
Pour installer Firecrawl pour Claude Desktop automatiquement via [Smithery](https://smithery.ai/server/@mendableai/mcp-server-firecrawl) :
```bash theme={null}
npx -y @smithery/cli install @mendableai/mcp-server-firecrawl --client claude
```
### Utilisation avec VS Code
Pour une installation en un clic, cliquez sur l'un des boutons d'installation ci-dessous...
[](https://insiders.vscode.dev/redirect/mcp/install?name=firecrawl\&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22apiKey%22%2C%22description%22%3A%22Firecrawl%20API%20Key%22%2C%22password%22%3Atrue%7D%5D\&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22firecrawl-mcp%22%5D%2C%22env%22%3A%7B%22FIRECRAWL_API_KEY%22%3A%22%24%7Binput%3AapiKey%7D%22%7D%7D) [](https://insiders.vscode.dev/redirect/mcp/install?name=firecrawl\&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22apiKey%22%2C%22description%22%3A%22Firecrawl%20API%20Key%22%2C%22password%22%3Atrue%7D%5D\&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22firecrawl-mcp%22%5D%2C%22env%22%3A%7B%22FIRECRAWL_API_KEY%22%3A%22%24%7Binput%3AapiKey%7D%22%7D%7D\&quality=insiders)
Pour une installation manuelle, ajoutez le bloc JSON suivant à votre fichier de paramètres utilisateur (JSON) dans VS Code. Vous pouvez le faire en appuyant sur `Ctrl + Shift + P` et en tapant `Preferences: Open User Settings (JSON)`.
```json theme={null}
{
"mcp": {
"inputs": [
{
"type": "promptString",
"id": "apiKey",
"description": "Clé API Firecrawl",
"password": true
}
],
"servers": {
"firecrawl": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "${input:apiKey}"
}
}
}
}
}
```
Vous pouvez également l’ajouter à un fichier nommé `.vscode/mcp.json` dans votre espace de travail. Cela vous permettra de partager la configuration avec d’autres :
```json theme={null}
{
"inputs": [
{
"type": "promptString",
"id": "apiKey",
"description": "Clé API Firecrawl",
"password": true
}
],
"servers": {
"firecrawl": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "${input:apiKey}"
}
}
}
}
```
**Remarque :** Certains utilisateurs ont signalé des problèmes lors de l'ajout du serveur MCP à VS Code, du fait que VS Code valide le JSON à l'aide d'un format de schéma obsolète ([microsoft/vscode#155379](https://github.com/microsoft/vscode/issues/155379)).
Cela affecte plusieurs outils MCP, dont Firecrawl.
**Solution de contournement :** Désactivez la validation JSON dans VS Code pour permettre au serveur MCP de se charger correctement.
Voir la discussion : [directus/directus#25906 (commentaire)](https://github.com/directus/directus/issues/25906#issuecomment-3369169513).
Le serveur MCP continue de fonctionner correctement lorsqu'il est invoqué via d'autres extensions, mais le problème se produit spécifiquement lors de son enregistrement directement dans la liste des serveurs MCP. Nous prévoyons d'ajouter des recommandations une fois que VS Code aura mis à jour la validation de son schéma.
### Utilisation avec Claude Desktop
Ajoutez ce qui suit au fichier de configuration de Claude :
```json theme={null}
{
"mcpServers": {
"firecrawl": {
"url": "https://mcp.firecrawl.dev/v2/mcp",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}
```
Si vous obtenez une erreur "Couldn't reach the MCP server", il se peut que votre version de Claude Desktop ne prenne pas en charge le transport HTTP en streaming. Utilisez plutôt l’approche locale avec npx (nécessite [Node.js](https://nodejs.org)) :
```json theme={null}
{
"mcpServers": {
"firecrawl": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "YOUR_API_KEY"
}
}
}
}
```
Si vous voyez une erreur `spawn npx ENOENT`, Node.js n’est pas installé ou ne figure pas dans le PATH de votre système. Installez Node.js depuis [nodejs.org](https://nodejs.org) (version LTS), puis redémarrez complètement Claude Desktop. Sous Windows, vous pouvez également exécuter `where npx` dans l’Invite de commandes et utiliser le chemin complet (par ex. `C:\\Program Files\\nodejs\\npx.cmd`) comme valeur de `command`.
### Utilisation avec Claude Code
Ajoutez le serveur MCP Firecrawl à l'aide de la CLI Claude Code. Vous pouvez utiliser l’URL hébergée à distance ou l’exécuter localement :
```bash theme={null}
# URL hébergée à distance (recommandé, fonctionne sans clé API)
claude mcp add --transport http firecrawl https://mcp.firecrawl.dev/v2/mcp
# Avec une clé API, envoyez-la dans un header Authorization
claude mcp add --transport http firecrawl https://mcp.firecrawl.dev/v2/mcp --header "Authorization: Bearer fc-your-api-key"
# Ou exécuter localement via npx
claude mcp add firecrawl -e FIRECRAWL_API_KEY=fc-your-api-key -- npx -y firecrawl-mcp
```
### Utilisation avec Google Antigravity
Google Antigravity vous permet de configurer des serveurs MCP directement depuis son interface Agent.
1. Ouvrez la barre latérale Agent dans l’Editor ou la vue Agent Manager
2. Cliquez sur le menu « … » (More Actions) et sélectionnez **MCP Servers**
3. Sélectionnez **View raw config** pour ouvrir votre fichier local `mcp_config.json`
4. Ajoutez la configuration suivante :
```json theme={null}
{
"mcpServers": {
"firecrawl": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "YOUR_FIRECRAWL_API_KEY"
}
}
}
}
```
5. Enregistrez le fichier et cliquez sur **Refresh** dans l’interface MCP d’Antigravity pour voir les nouveaux outils.
Remplacez `YOUR_FIRECRAWL_API_KEY` par votre clé API à partir de [https://firecrawl.dev/app/api-keys](https://www.firecrawl.dev/app/api-keys).
### Utilisation avec n8n
Pour connecter le serveur MCP Firecrawl dans n8n :
1. Récupérez votre clé API Firecrawl à partir de [https://firecrawl.dev/app/api-keys](https://www.firecrawl.dev/app/api-keys)
2. Dans votre workflow n8n, ajoutez un nœud **AI Agent**
3. Dans la configuration du nœud **AI Agent**, ajoutez un nouveau **Tool**
4. Sélectionnez **MCP Client Tool** comme type d’outil
5. Saisissez l’Endpoint du serveur MCP :
```
https://mcp.firecrawl.dev/v2/mcp
```
6. Définissez **Server Transport** sur **HTTP Streamable**
7. Définissez **Authentication** sur **Bearer** et collez votre clé API Firecrawl, ou laissez **None** pour utiliser le palier gratuit sans clé
8. Pour **Tools to include**, vous pouvez sélectionner **All**, **Selected** ou **All Except** – cela rendra disponibles les outils Firecrawl (scrape, crawl, map, search, extract, etc.)
Pour les déploiements auto-hébergés, exécutez le serveur MCP avec npx et activez le mode de transport HTTP :
```bash theme={null}
env HTTP_STREAMABLE_SERVER=true \
FIRECRAWL_API_KEY=fc-YOUR_API_KEY \
FIRECRAWL_API_URL=YOUR_FIRECRAWL_INSTANCE \
npx -y firecrawl-mcp
```
Cela démarre le serveur sur `http://localhost:3000/v2/mcp`, que vous pouvez utiliser comme endpoint dans votre workflow n8n. La variable d'environnement `HTTP_STREAMABLE_SERVER=true` est requise, car n8n a besoin d'un transport via HTTP.
## Configuration
### Variables d’environnement
#### API cloud et auto-hébergée
* `FIRECRAWL_API_KEY` : votre clé API Firecrawl
* Requise lors de l’utilisation de l’API cloud (par défaut)
* Facultative lors de l’utilisation d’une instance auto-hébergée avec `FIRECRAWL_API_URL`
* `FIRECRAWL_API_URL` (facultatif) : point de terminaison API personnalisé pour les instances auto-hébergées
* Exemple : `https://firecrawl.your-domain.com`
* Si elle n’est pas renseignée, l’API cloud sera utilisée (nécessite une clé API)
### Exemples de configuration
Pour l’utilisation de l’API cloud :
```bash theme={null}
export FIRECRAWL_API_KEY=your-api-key
```
Pour une instance auto‑hébergée :
```bash theme={null}
export FIRECRAWL_API_URL=https://firecrawl.your-domain.com
export FIRECRAWL_API_KEY=your-api-key # Si votre instance requiert une authentification
```
### Configuration personnalisée avec Claude Desktop
Ajoutez ceci dans votre `claude_desktop_config.json` :
```json theme={null}
{
"mcpServers": {
"mcp-server-firecrawl": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "YOUR_API_KEY_HERE"
}
}
}
}
```
### MCP hébergé vs MCP local
Le serveur MCP hébergé est optimisé pour une utilisation à distance sécurisée. Certaines options disponibles lorsque vous exécutez le serveur MCP localement sont restreintes ou indisponibles à distance :
* Le mode keyless hébergé n’expose que les outils pris en charge en mode keyless et est soumis à une limitation de débit par IP.
* La lecture de fichiers locaux n’est disponible que lorsque vous exécutez le serveur MCP localement.
* Les Webhooks et les chemins de fichiers locaux doivent être configurés à partir d’un serveur MCP local ou self-hosted lorsque l’agent doit accéder à des ressources locales.
### Limites de débit
Les limites de débit sont appliquées par Firecrawl. Utilisez une clé API pour bénéficier de limites plus élevées et accéder à l’ensemble des outils.
## Outils disponibles
### 1. Outil de scraping (`firecrawl_scrape`)
Extraire le contenu d’une URL unique avec des options avancées.
```json theme={null}
{
"name": "firecrawl_scrape",
"arguments": {
"url": "https://example.com",
"formats": ["markdown"],
"onlyMainContent": true,
"waitFor": 1000,
"mobile": false,
"includeTags": ["article", "main"],
"excludeTags": ["nav", "footer"],
"skipTlsVerification": false
}
}
```
Pour masquer les données personnelles identifiables, incluez `redactPII` dans les arguments de l’outil de scraping.
```json theme={null}
{
"name": "firecrawl_scrape",
"arguments": {
"url": "https://example.com/contact",
"formats": ["markdown"],
"redactPII": true
}
}
```
### 2. Outil de cartographie (`firecrawl_map`)
Cartographier un site web pour découvrir toutes les URL indexées du site.
```json theme={null}
{
"name": "firecrawl_map",
"arguments": {
"url": "https://example.com",
"search": "blog",
"sitemap": "include",
"includeSubdomains": false,
"limit": 100,
"ignoreQueryParameters": true
}
}
```
#### Options de l’outil Map :
* `url`: L’URL de base du site web à cartographier
* `search`: Terme de recherche facultatif pour filtrer les URL
* `sitemap`: Contrôle l’utilisation du sitemap : « include », « skip » ou « only »
* `includeSubdomains`: Indique s’il faut inclure les sous-domaines dans la cartographie
* `limit`: Nombre maximal d’URL à retourner
* `ignoreQueryParameters`: Indique s’il faut ignorer les paramètres de requête lors de la cartographie
**Idéal pour :** Découvrir les URL d’un site web avant de décider quoi extraire ; trouver des sections spécifiques d’un site.
**Renvoie :** Tableau d’URL trouvées sur le site.
### 3. Outil de recherche (`firecrawl_search`)
Effectuez une recherche sur le web et, si besoin, extrayez le contenu des résultats.
```json theme={null}
{
"name": "firecrawl_search",
"arguments": {
"query": "votre requête de recherche",
"limit": 5,
"location": "United States",
"tbs": "qdr:m",
"scrapeOptions": {
"formats": ["markdown"],
"onlyMainContent": true
}
}
}
```
#### Options de l'outil de recherche :
* `query` : chaîne de requête de recherche (obligatoire)
* `limit` : nombre maximal de résultats à retourner
* `location` : emplacement géographique pour les résultats de recherche
* `tbs` : filtre temporel de recherche (par exemple, `qdr:d` pour les dernières 24 heures, `qdr:w` pour la dernière semaine, `qdr:m` pour le dernier mois)
* `filter` : filtre de recherche supplémentaire
* `sources` : tableau des types de sources à interroger (`web`, `images`, `news`)
* `scrapeOptions` : options de scraping des pages de résultats de recherche
* `enterprise` : tableau d’options d’entreprise (`default`, `anon`, `zdr`)
### 4. Outil de parsing (`firecrawl_parse`)
Convertissez un fichier local, tel qu’un document PDF, DOCX, XLSX ou HTML, en données propres, prêtes pour les LLM.
```json theme={null}
{
"name": "firecrawl_parse",
"arguments": {
"filePath": "/absolute/path/to/report.pdf",
"formats": ["markdown"]
}
}
```
Lorsque vous exécutez Firecrawl MCP localement sur une instance de l’API Firecrawl avec `FIRECRAWL_API_URL`, le serveur MCP peut lire directement `filePath` et envoie les octets du fichier à `/v2/parse`.
Lorsque vous utilisez le serveur MCP distant hébergé, celui-ci ne peut pas lire les fichiers de votre machine. Dans ce cas, `firecrawl_parse` utilise un transfert en deux étapes qui fonctionne également avec l’URL distante sans clé :
1. Appelez `firecrawl_parse` avec `filePath`. L’outil renvoie une commande d’upload préremplie et un `nextToolCall` contenant un `uploadRef`.
2. Exécutez la commande d’upload sur la machine qui peut lire le fichier, puis appelez à nouveau `firecrawl_parse` avec l’`uploadRef` renvoyé.
La commande d’upload envoie les octets du fichier vers une cible d’upload signée à durée de vie limitée. Elle n’inclut pas votre clé API Firecrawl.
#### Options de l’outil de parsing :
* `filePath` : Chemin local vers le fichier que vous souhaitez analyser. À utiliser pour le premier appel.
* `uploadRef` : Référence renvoyée par le premier appel hosted-MCP. À utiliser pour le second appel une fois le téléversement terminé.
* `formats` : Formats de sortie. Valeur par défaut : `markdown`.
* `parsers` : Paramètres du parseur, comme les options d’analyse PDF.
* `contentType` : Remplacement facultatif du type MIME du fichier.
* `declaredSizeBytes` : Indication facultative de la taille du fichier. Les fichiers sont limités à 50 Mo.
**Idéal pour :** Les documents locaux ou non publics qui ne sont pas disponibles via une URL publique.
**Non recommandé pour :** Les URL de documents publics. Utilisez plutôt `firecrawl_scrape` ; il détectera et analysera les documents à partir des URL.
### 5. Outil de crawl (`firecrawl_crawl`)
Démarre un crawl asynchrone avec des options avancées.
```json theme={null}
{
"name": "firecrawl_crawl",
"arguments": {
"url": "https://example.com",
"maxDiscoveryDepth": 2,
"limit": 100,
"allowExternalLinks": false,
"deduplicateSimilarURLs": true
}
}
```
### 6. Vérifier l'état du crawl (`firecrawl_check_crawl_status`)
Vérifiez l'état d'une tâche de crawl.
```json theme={null}
{
"name": "firecrawl_check_crawl_status",
"arguments": {
"id": "550e8400-e29b-41d4-a716-446655440000"
}
}
```
**Renvoie :** le statut et l'avancement du job de crawl, y compris les résultats le cas échéant.
Extrait des informations structurées depuis des pages web en utilisant les capacités des LLM. Prend en charge aussi bien l’IA dans le cloud que l’extraction avec des LLM auto-hébergés.
```json theme={null}
{
"name": "firecrawl_extract",
"arguments": {
"urls": ["https://example.com/page1", "https://example.com/page2"],
"prompt": "Extract product information including name, price, and description",
"schema": {
"type": "object",
"properties": {
"name": { "type": "string" },
"price": { "type": "number" },
"description": { "type": "string" }
},
"required": ["name", "price"]
},
"allowExternalLinks": false,
"enableWebSearch": false,
"includeSubdomains": false
}
}
```
Exemple de réponse :
```json theme={null}
{
"content": [
{
"type": "text",
"text": {
"name": "Example Product",
"price": 99.99,
"description": "This is an example product description"
}
}
],
"isError": false
}
```
* `urls`: Liste d’URL à partir desquelles extraire des informations
* `prompt`: Prompt personnalisé pour l’extraction par le LLM
* `schema`: Schéma JSON pour l’extraction de données structurées
* `allowExternalLinks`: Autoriser l’extraction à partir de liens externes
* `enableWebSearch`: Activer la recherche sur le web pour obtenir un contexte supplémentaire
* `includeSubdomains`: Inclure les sous-domaines dans l’extraction
Lors de l’utilisation d’une instance auto‑hébergée, l’extraction utilisera le LLM que vous avez configuré. Pour l’API cloud, elle utilise le service LLM géré de Firecrawl.
### 8. Outil Agent (`firecrawl_agent`)
Agent autonome de recherche web qui parcourt Internet de manière indépendante, recherche des informations, navigue entre les pages et extrait des données structurées en fonction de votre requête. Ce processus s’exécute de façon asynchrone : il renvoie immédiatement un ID de tâche, puis vous interrogez périodiquement `firecrawl_agent_status` pour savoir quand il est terminé et récupérer les résultats.
```json theme={null}
{
"name": "firecrawl_agent",
"arguments": {
"prompt": "Find the top 5 AI startups founded in 2024 and their funding amounts",
"schema": {
"type": "object",
"properties": {
"startups": {
"type": "array",
"items": {
"type": "object",
"properties": {
"name": { "type": "string" },
"funding": { "type": "string" },
"founded": { "type": "string" }
}
}
}
}
}
}
}
```
Vous pouvez également fournir des URL spécifiques sur lesquelles l’agent devra se concentrer :
```json theme={null}
{
"name": "firecrawl_agent",
"arguments": {
"urls": ["https://docs.firecrawl.dev", "https://firecrawl.dev/pricing"],
"prompt": "Compare the features and pricing information from these pages"
}
}
```
#### Options de l'Agent Tool :
* `prompt`: Description en langage naturel des données dont vous avez besoin (obligatoire, 10 000 caractères maximum)
* `urls`: Tableau optionnel d’URL pour concentrer l’agent sur des pages spécifiques
* `schema`: Schéma JSON optionnel pour une sortie structurée
**Idéal pour :** Tâches de recherche complexes où vous ne connaissez pas les URL exactes ; collecte de données issues de multiples sources ; recherche d’informations dispersées sur le web ; extraction de données à partir de SPA lourdes en JavaScript qui échouent avec un scraping classique.
**Retourne :** ID de tâche pour vérifier l’état d’avancement. Utilisez `firecrawl_agent_status` pour interroger les résultats.
### 9. Vérifier le statut de l'agent (`firecrawl_agent_status`)
Vérifiez l'état d'une tâche d'agent et récupérez les résultats une fois terminée. Effectuez un polling toutes les 15 à 30 secondes et continuez pendant au moins 2 à 3 minutes avant de considérer la requête comme échouée.
```json theme={null}
{
"name": "firecrawl_agent_status",
"arguments": {
"id": "550e8400-e29b-41d4-a716-446655440000"
}
}
```
#### Options de statut de l'agent :
* `id`: L'ID de tâche d'agent renvoyé par `firecrawl_agent` (obligatoire)
**Statuts possibles :**
* `processing`: L'agent est encore en cours de recherche -- continuer à interroger
* `completed`: Recherche terminée -- la réponse inclut les données extraites
* `failed`: Une erreur s'est produite
**Retourne :** Le statut, la progression et les résultats (si terminé) de la tâche d'agent.
### 10. Interagir avec une page (`firecrawl_interact`)
Interagissez avec une page dans une session de navigateur active : cliquez sur des boutons, remplissez des formulaires, extrayez du contenu dynamique ou naviguez plus en profondeur.
Utilisez l’un des deux modes de ciblage :
* Passez `url` pour ouvrir une nouvelle page et interagir avec elle en un seul appel MCP.
* Passez `scrapeId` depuis un appel `firecrawl_scrape` précédent pour réutiliser la page déjà chargée.
Ne passez pas à la fois `url` et `scrapeId`. Fournissez soit `prompt`, soit `code`. `scrapeOptions` ne peut être utilisé qu’en mode `url`.
**Exemple en mode URL :**
```json theme={null}
{
"name": "firecrawl_interact",
"arguments": {
"url": "https://example.com/products",
"prompt": "Click on the first product and tell me its price"
}
}
```
**Exemple de réutilisation de Scrape :**
```json theme={null}
{
"name": "firecrawl_interact",
"arguments": {
"scrapeId": "scrape-id-from-previous-scrape",
"prompt": "Click the Sign In button"
}
}
```
#### Options de l’outil Interact :
* `url` : Page avec laquelle interagir ; ouvre la session pour vous. Utilisez ceci ou `scrapeId`.
* `scrapeId` : L’ID de tâche d’une tâche de scraping issue d’un appel précédent à `firecrawl_scrape`. Utilisez ceci ou `url`.
* `prompt` : Instruction en langage naturel décrivant l’action à effectuer. Fournissez `prompt` ou `code`.
* `code` : Code à exécuter dans la session de navigateur. Fournissez `code` ou `prompt`.
* `language` : `bash`, `python` ou `node` (facultatif, valeur par défaut : `node`, utilisé uniquement avec `code`).
* `timeout` : Délai d’exécution maximal, en secondes, de 1 à 300 (facultatif, valeur par défaut : 30).
* `scrapeOptions` : Options de scraping facultatives, utilisées uniquement avec le mode `url`.
**Idéal pour :** Les workflows en plusieurs étapes sur une seule page — effectuer des recherches sur un site, cliquer dans les résultats, remplir des formulaires, extraire des données nécessitant une interaction.
**Renvoie :** Le résultat de l’interaction, y compris les URL de sortie et de vue en direct.
### 11. Arrêter une session Interact (`firecrawl_interact_stop`)
Arrêtez une session Interact pour une page scrapée. Appelez cette opération une fois l’interaction terminée afin de libérer des ressources.
```json theme={null}
{
"name": "firecrawl_interact_stop",
"arguments": {
"scrapeId": "scrape-id-from-previous-scrape"
}
}
```
#### Options d’arrêt d’Interact :
* `scrapeId` : l’ID du scrape de la session à arrêter (obligatoire)
**Renvoie :** confirmation que la session a été arrêtée.
## Système de journalisation
Le serveur inclut une journalisation complète :
* État et progression des opérations
* Indicateurs de performance
* Suivi de l’utilisation des crédits
* Suivi des limites de débit
* Conditions d’erreur
Exemples de messages de journal :
```
[INFO] Firecrawl MCP Server initialized successfully
[INFO] Starting scrape for URL: https://example.com
[INFO] Starting crawl for URL: https://example.com
[WARNING] L'utilisation des crédits a atteint le seuil d'alerte
[ERROR] Rate limit exceeded, retrying in 2s...
```
## Gestion des erreurs
Le serveur propose une gestion robuste des erreurs :
* Nouveaux essais automatiques en cas d’erreurs transitoires
* Gestion des limites de débit avec backoff
* Messages d’erreur détaillés
* Alertes sur l’utilisation des crédits
* Résilience du réseau
Exemple de réponse d’erreur :
```json theme={null}
{
"content": [
{
"type": "text",
"text": "Erreur : Limite de débit dépassée. Nouvelle tentative dans 2 secondes..."
}
],
"isError": true
}
```
## Développement
```bash theme={null}
# Installer les dépendances
npm install
# Build
npm run build
# Run tests
npm test
```
### Contribution
1. Créez un fork du dépôt
2. Créez une branche pour votre fonctionnalité
3. Exécutez les tests : `npm test`
4. Ouvrez une pull request
### Merci aux contributeurs
Merci à [@vrknetha](https://github.com/vrknetha) et [@cawstudios](https://caw.tech) pour la mise en œuvre initiale !
Merci à MCP.so et Klavis AI pour l’hébergement, ainsi qu’à [@gstarwd](https://github.com/gstarwd), [@xiangkaiz](https://github.com/xiangkaiz) et [@zihaolin96](https://github.com/zihaolin96) d’avoir intégré notre serveur.
## Licence
Licence MIT — voir le fichier LICENSE pour plus de détails