> ## Documentation Index > Fetch the complete documentation index at: https://firecrawl-claude-eager-dijkstra-lr4978.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Agent > Collectez les données où qu'elles se trouvent sur le web. **Choisir le bon outil.** Agent est le bon choix lorsque vous **ne connaissez pas les URL** ou que vous avez besoin d’une navigation autonome sur le web. * Pour **une URL unique déjà connue**, le [mode JSON sur `/scrape`](/fr/features/llm-extract) est plus économique et synchrone. * Comparaison complète : [Choisir l’extracteur de données](/fr/developer-guides/usage-guides/choosing-the-data-extractor). Firecrawl `/agent` est une API révolutionnaire qui recherche, parcourt et collecte des données depuis la plus grande variété de sites web, trouvant des données dans des endroits difficiles d’accès et les mettant au jour d’une manière qu’aucune autre API ne peut égaler. Elle accomplit en quelques minutes ce qui prendrait de nombreuses heures à un humain — une collecte de données de bout en bout, sans scripts ni intervention manuelle. Que vous ayez besoin d’un seul point de données ou de jeux de données complets à grande échelle, Firecrawl `/agent` s’occupe de récupérer vos données. **Considérez `/agent` comme une recherche approfondie de données, où qu’elles se trouvent !** **Research Preview** : Agent est en accès anticipé. Attendez-vous à quelques limitations. Il s’améliorera considérablement au fil du temps.
Prime : 5 000 crédits de récompense pour des retours de qualité sur /agent

Pour être éligible, participez à un entretien approfondi (cas d'utilisation concrets et réfléchis, etc.) avec notre assistant de retours Firecrawl. Cela ne prend que quelques minutes, peut être interrompu à tout moment et convient aussi bien aux humains qu'aux agents (collez simplement le lien dans votre harnais agentique !). Vous n'avez jamais utilisé /agent ? Votre avis compte quand même.

Démarrer l'entretien

Indiquez votre e-mail pour être éligible. Les entretiens sont évalués en fin de semaine.

Agent s’appuie sur tout ce qui fait la force de `/extract` et va encore plus loin : * **Aucune URL requise** : Décrivez simplement ce dont vous avez besoin via le paramètre `prompt`. Les URL sont facultatives. * **Recherche web approfondie** : Explore et navigue automatiquement en profondeur dans les sites pour trouver vos données * **Fiable et précis** : Fonctionne avec un large éventail de requêtes et de cas d'utilisation * **Plus rapide** : Traite plusieurs sources en parallèle pour des résultats plus rapides Testez l'agent dans le Playground interactif — aucun code nécessaire.
## Utilisation de `/agent`
Le seul paramètre requis est `prompt`. Décrivez simplement les données que vous souhaitez extraire. Pour une sortie structurée, fournissez un schéma JSON. Les SDK prennent en charge Pydantic (Python) et Zod (Node) pour des définitions de schémas avec typage sûr : ```python Python theme={null} from firecrawl import Firecrawl from pydantic import BaseModel, Field from typing import List, Optional app = Firecrawl(api_key="fc-YOUR_API_KEY") class Founder(BaseModel): name: str = Field(description="Full name of the founder") role: Optional[str] = Field(None, description="Role or position") background: Optional[str] = Field(None, description="Professional background") class FoundersSchema(BaseModel): founders: List[Founder] = Field(description="List of founders") result = app.agent( prompt="Find the founders of Firecrawl", schema=FoundersSchema, model="spark-2", max_credits=100 ) print(result.data) ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; import { z } from 'zod'; const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" }); const result = await firecrawl.agent({ prompt: "Find the founders of Firecrawl", schema: z.object({ founders: z.array(z.object({ name: z.string().describe("Full name of the founder"), role: z.string().describe("Role or position").optional(), background: z.string().describe("Professional background").optional() })).describe("List of founders") }), model: "spark-2", maxCredits: 100 }); console.log(result.data); ``` ```bash cURL theme={null} curl -X POST "https://api.firecrawl.dev/v2/agent" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "prompt": "Find the founders of Firecrawl", "model": "spark-2", "maxCredits": 100, "schema": { "type": "object", "properties": { "founders": { "type": "array", "description": "List of founders", "items": { "type": "object", "properties": { "name": { "type": "string", "description": "Full name" }, "role": { "type": "string", "description": "Role or position" }, "background": { "type": "string", "description": "Parcours professionnel" } }, "required": ["name"] } } }, "required": ["founders"] } }' ```
### Réponse
```json JSON theme={null} { "success": true, "status": "completed", "data": { "founders": [ { "name": "Eric Ciarla", "role": "Co-founder", "background": "Previously at Mendable" }, { "name": "Nicolas Camara", "role": "Co-founder", "background": "Previously at Mendable" }, { "name": "Caleb Peffer", "role": "Co-founder", "background": "Previously at Mendable" } ] }, "expiresAt": "2024-12-15T00:00:00.000Z", "creditsUsed": 15 } ```
## Fournir des URL (facultatif)
Vous pouvez éventuellement fournir des URL pour cibler l’agent sur des pages spécifiques : ```python Python theme={null} from firecrawl import Firecrawl app = Firecrawl(api_key="fc-YOUR_API_KEY") result = app.agent( urls=["https://docs.firecrawl.dev", "https://firecrawl.dev/pricing"], prompt="Comparez les fonctionnalités et les informations de tarification de ces pages" ) print(result.data) ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" }); const result = await firecrawl.agent({ urls: ["https://docs.firecrawl.dev", "https://firecrawl.dev/pricing"], prompt: "Compare the features and pricing information from these pages" }); console.log(result.data); ``` ```bash cURL theme={null} curl -X POST "https://api.firecrawl.dev/v2/agent" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "urls": [ "https://docs.firecrawl.dev", "https://firecrawl.dev/pricing" ], "prompt": "Compare the features and pricing information from these pages" }' ```
## Statut et fin de la tâche
Les tâches d'agent s'exécutent de manière asynchrone. Lorsque vous soumettez une tâche, vous recevez un ID de tâche que vous pouvez utiliser pour consulter son statut : * **Méthode par défaut** : `agent()` attend la fin de l'exécution et renvoie les résultats finaux * **Démarrer puis interroger** : utilisez `start_agent` (Python) ou `startAgent` (Node) pour obtenir immédiatement un ID de tâche, puis interrogez avec `get_agent_status` / `getAgentStatus` * **Notification push au lieu d'interroger** : transmettez un `webhook` lorsque vous démarrez la tâche afin de recevoir des [événements d'agent](/fr/webhooks/events#agent-events) au fur et à mesure que l'exécution progresse et se termine Les résultats de la tâche sont accessibles via l'API pendant 24 heures après la fin de l'exécution. Après cette période, vous pouvez toujours consulter l'historique et les résultats de votre agent dans les [journaux d'activité](https://www.firecrawl.dev/app/logs). ```python Python theme={null} from firecrawl import Firecrawl app = Firecrawl(api_key="fc-YOUR_API_KEY") # Démarrer une tâche d'agent agent_job = app.start_agent( prompt="Find the founders of Firecrawl" ) # Check the status status = app.get_agent_status(agent_job.id) print(status) # Example output: # status='completed' # success=True # data={ ... } # expires_at=datetime.datetime(...) # credits_used=15 ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" }); // Lancer une tâche d'agent const started = await firecrawl.startAgent({ prompt: "Find the founders of Firecrawl" }); // Vérifier le statut if (started.id) { const status = await firecrawl.getAgentStatus(started.id); console.log(status.status, status.data); } ``` ```bash cURL theme={null} curl -X GET "https://api.firecrawl.dev/v2/agent/" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" ```
### États possibles
| État | Description | | ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- | | `processing` | L’agent traite toujours votre requête | | `completed` | L’extraction s’est terminée avec succès | | `failed` | Une erreur s’est produite lors de l’extraction, ou la tâche a été annulée (les tâches annulées signalent `failed` avec un message d’erreur d’annulation) | **L’annulation est coopérative.** Lorsque vous appelez le point de terminaison d’annulation, la requête est enregistrée immédiatement, mais toute étape déjà en cours (une étape de raisonnement du LLM, un appel d’outil ou une action du navigateur) se poursuit jusqu’à un point d’arrêt propre avant que la tâche ne s’arrête. Des crédits peuvent continuer à s’accumuler pendant ce court laps de temps ; la valeur finale de `creditsUsed` peut donc être supérieure à celle indiquée au moment où vous avez cliqué sur annuler. Une tâche annulée signale l’état `failed` lorsqu’elle est interrogée et émet un événement Webhook `agent.cancelled`.
#### Exemple en attente
```json JSON theme={null} { "success": true, "status": "processing", "expiresAt": "2024-12-15T00:00:00.000Z" } ```
#### Exemple complété
```json JSON theme={null} { "success": true, "status": "completed", "data": { "founders": [ { "name": "Eric Ciarla", "role": "Co-founder" }, { "name": "Nicolas Camara", "role": "Co-founder" }, { "name": "Caleb Peffer", "role": "Co-founder" } ] }, "expiresAt": "2024-12-15T00:00:00.000Z", "creditsUsed": 15 } ```
## Liste des exécutions d’agent
`GET /agent` répertorie toutes les exécutions d’agent de votre équipe, de la plus récente à la plus ancienne, y compris celles lancées depuis le playground ou l’API. Chaque entrée contient l’ID de l’exécution, sa date de création, son état, un bref aperçu de la cible et les options avec lesquelles elle a été lancée. Les résultats sont répartis en pages fixes de 20 exécutions. Lorsque d’autres pages sont disponibles, la réponse inclut une URL `next` ; transmettez son horodatage `before` pour récupérer la page suivante. Les méthodes du SDK ne gèrent pas automatiquement la pagination, ce qui vous permet de décider jusqu’où remonter. ```python Python theme={null} from firecrawl import Firecrawl app = Firecrawl(api_key="fc-YOUR_API_KEY") # Lister vos exécutions d’agent les plus récentes page = app.list_agents() for run in page.agents: print(run.id, run.status, run.target_hint) # Récupérer la page suivante à l’aide du curseur fourni par `next` if page.next: before = int(page.next.split("before=")[-1]) older = app.list_agents(before=before) ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" }); // Lister vos exécutions d'agent les plus récentes const page = await firecrawl.listAgents(); for (const run of page.agents ?? []) { console.log(run.id, run.status, run.targetHint); } // Récupérer la page suivante à l'aide du curseur fourni par `next` if (page.next) { const before = Number(new URL(page.next).searchParams.get("before")); const older = await firecrawl.listAgents({ before }); } ``` ```bash cURL theme={null} curl -X GET "https://api.firecrawl.dev/v2/agent" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" # Récupérer la page suivante (horodatage unix en ms provenant de l'URL `next` de la page précédente) curl -X GET "https://api.firecrawl.dev/v2/agent?before=1756600000000" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" ```
## Suivre une exécution en cours
Agent ne maintient pas de connexion de streaming ouverte. Il n'y a ni flux d'événements envoyés par le serveur ni WebSocket. Vous pouvez donc suivre une exécution en interrogeant sa trace ou en recevant des webhooks. | Surface | Ce que vous obtenez | Idéal pour | | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | | Interrogation de la trace | Tous les détails : chaque événement émis jusqu'à présent par l'exécution, y compris les appels d'outils, les résumés du raisonnement, les phases de progression et les modifications d'artefacts | Créer votre propre interface de suivi de la progression ou déboguer ce qu'une exécution a réellement fait | | Webhooks | Envoi push, peu détaillé : les cinq événements du cycle de vie de l'agent (`agent.started`, `agent.action`, `agent.completed`, `agent.failed`, `agent.cancelled`). Consultez les [événements webhook](/fr/webhooks/events) | Réagir à la fin d'une exécution sans maintenir une boucle d'interrogation active | | Vue en direct | Une vue du navigateur de l'agent qu'un humain peut surveiller. Demandez la trace avec `?liveView=true` et chaque entrée de `activeBrowserSessions` contient une `liveViewUrl` | Observer une exécution naviguer en temps réel | Lorsque vous triez vous-même les événements de trace, regroupez-les d'abord par `agent.id` : `producerSequence` est monotone pour chaque agent émetteur ; un tri global unique entremêle donc incorrectement les événements d'un orchestrateur et ceux de ses sous-agents. Des événements peuvent également arriver brièvement après l'événement terminal `run.finished`. Continuez donc à interroger pendant une courte période après celui-ci avant d'afficher l'état final. ```python Python theme={null} import time from collections import defaultdict from firecrawl import Firecrawl app = Firecrawl(api_key="fc-YOUR_API_KEY") agent_job = app.start_agent(prompt="Find the founders of Firecrawl") seen = set() finished = False quiet_polls = 0 while True: trace = app.get_agent_trace(agent_job.id) # producer_sequence est monotone par agent émetteur : on regroupe donc d'abord. by_agent = defaultdict(list) for event in trace.events or []: by_agent[event.agent.id].append(event) new_events = 0 for agent_id, events in by_agent.items(): for event in sorted(events, key=lambda e: e.producer_sequence): if event.event_id not in seen: seen.add(event.event_id) new_events += 1 print(agent_id, event.producer_sequence, event.type) if not finished: finished = app.get_agent_status(agent_job.id).status != "processing" elif new_events: quiet_polls = 0 else: # Fenêtre de fin : des événements peuvent encore arriver un instant après la fin de l'exécution. quiet_polls += 1 if quiet_polls == 3: break time.sleep(5) ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" }); const started = await firecrawl.startAgent({ prompt: "Find the founders of Firecrawl" }); const seen = new Set(); let finished = false; let quietPolls = 0; for (;;) { const trace = await firecrawl.getAgentTrace(started.id); // producerSequence est monotone par agent émetteur : on regroupe donc d'abord. const byAgent = new Map(); for (const event of trace.events ?? []) { const bucket = byAgent.get(event.agent.id) ?? []; bucket.push(event); byAgent.set(event.agent.id, bucket); } let newEvents = 0; for (const [agentId, events] of byAgent) { for (const event of events.sort((a, b) => a.producerSequence - b.producerSequence)) { if (seen.has(event.eventId)) continue; seen.add(event.eventId); newEvents++; console.log(agentId, event.producerSequence, event.type); } } if (!finished) { finished = (await firecrawl.getAgentStatus(started.id)).status !== "processing"; } else if (newEvents) { quietPolls = 0; } else { // Fenêtre de fin : des événements peuvent encore arriver quelques instants après la fin de l'exécution. if (++quietPolls === 3) break; } await new Promise((resolve) => setTimeout(resolve, 5000)); } ``` ```bash cURL theme={null} # N'affiche que les événements pas encore vus, et continue d'interroger pendant # une courte fenêtre après la fin de l'exécution. tmp=$(mktemp -d) trap 'rm -rf "$tmp"' EXIT : > "$tmp/seen.txt" finished=0 quiet=0 while [ "$quiet" -lt 3 ]; do curl -s "https://api.firecrawl.dev/v2/agent/JOB_ID/trace" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" \ | jq -r '.events | group_by(.agent.id)[] | sort_by(.producerSequence)[] | "\(.eventId) \(.agent.id) \(.producerSequence) \(.type)"' > "$tmp/poll.txt" new=$(grep -vxF -f "$tmp/seen.txt" "$tmp/poll.txt") [ -n "$new" ] && echo "$new" cp "$tmp/poll.txt" "$tmp/seen.txt" if [ "$finished" = 0 ]; then status=$(curl -s "https://api.firecrawl.dev/v2/agent/JOB_ID" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" | jq -r '.status') [ "$status" = "processing" ] || finished=1 elif [ -n "$new" ]; then quiet=0 else quiet=$((quiet + 1)) fi sleep 5 done ```
## Traces d’exécution et instantanés
Chaque exécution enregistre une trace d’exécution canonique — une suite ordonnée d’événements couvrant les appels d’outils, les résumés de raisonnement, les mises à jour de progression, les sessions de navigateur et les modifications des artefacts de sortie. Récupérez-la pour déboguer une exécution ou alimenter une interface de suivi de progression en temps réel : ```python Python theme={null} from firecrawl import Firecrawl app = Firecrawl(api_key="fc-YOUR_API_KEY") # Trace d'exécution d'une exécution : événements ordonnés (tool calls, raisonnement, artefacts) trace = app.get_agent_trace("JOB_ID") for event in trace.events or []: print(event.type) # Inclure les sessions de navigateur actuellement actives pendant que l'exécution est en cours live = app.get_agent_trace("JOB_ID", live_view=True) for session in live.active_browser_sessions or []: print(session.live_view_url) ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" }); // Trace d'exécution d'un run : événements ordonnés (tool calls, raisonnement, artefacts) const trace = await firecrawl.getAgentTrace("JOB_ID"); for (const event of trace.events ?? []) { console.log(event.type); } // Inclure les sessions de navigateur actives pendant que le run est en cours const live = await firecrawl.getAgentTrace("JOB_ID", { liveView: true }); console.log(live.activeBrowserSessions); ``` ```bash cURL theme={null} curl "https://api.firecrawl.dev/v2/agent/JOB_ID/trace" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" # Inclure les sessions de navigateur actives pendant que l'exécution est en cours curl "https://api.firecrawl.dev/v2/agent/JOB_ID/trace?liveView=true" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" ``` Les événements de trace `artifact.updated` font référence à la sortie de travail de l’agent via `snapshotId`. Récupérez le contenu complet d’un instantané à l’aide du point de terminaison des instantanés : ```python Python theme={null} from firecrawl import Firecrawl app = Firecrawl(api_key="fc-YOUR_API_KEY") # Les événements de trace artifact.updated font référence au contenu du snapshot via snapshotId snapshot = app.get_agent_snapshot("JOB_ID", "SNAPSHOT_ID") print(snapshot.snapshot) ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" }); // les événements de trace artifact.updated référencent le contenu du snapshot via snapshotId const snapshot = await firecrawl.getAgentSnapshot("JOB_ID", "SNAPSHOT_ID"); console.log(snapshot.snapshot); ``` ```bash cURL theme={null} curl "https://api.firecrawl.dev/v2/agent/JOB_ID/snapshots/SNAPSHOT_ID" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" ``` Les traces et les instantanés sont enregistrés pour les exécutions Spark 2, c’est-à-dire toutes les nouvelles exécutions ; les tâches démarrées sur des modèles Spark 1 avant leur retrait n’en disposent pas. Consultez les références d’API [trace](/fr/api-reference/endpoint/agent-trace) et [snapshot](/fr/api-reference/endpoint/agent-snapshot) pour obtenir le schéma complet des événements, ainsi que le catalogue [Erreurs d’agent](/fr/api-reference/errors#agent) pour connaître les échecs renvoyés par ces points de terminaison.
## Récupérer les données sources de l'agent
Au fil de son exécution, une exécution écrit sa sortie de travail dans des artefacts, que vous pouvez récupérer une fois que vous avez obtenu sa trace. Chaque événement `artifact.updated` décrit une modification d'un artefact : `artifact.kind` vaut `json`, `markdown`, `html`, `screenshot` ou `text`, `artifact.path` indique où l'exécution l'a placé et `artifact.snapshotId` est l'identifiant à utiliser pour récupérer son contenu via `GET /agent/{jobId}/snapshots/{snapshotId}`. Le point de terminaison des instantanés renvoie ce contenu dans un champ `snapshot` sous forme de chaîne : pour les artefacts `json`, cette chaîne est encodée en JSON et doit être décodée ; pour les artefacts `markdown`, `html` et `text`, elle correspond directement au contenu. Pour récupérer le contenu de page produit par une exécution, récupérez la trace, conservez les événements `artifact.updated` dont le `kind` vous intéresse, puis récupérez chaque instantané : ```python Python theme={null} import json from firecrawl import Firecrawl app = Firecrawl(api_key="fc-VOTRE_CLÉ_API") trace = app.get_agent_trace("JOB_ID") for event in trace.events or []: if event.type != "artifact.updated": continue kind = event.artifact.kind if kind not in ("markdown", "html", "json"): continue snapshot = app.get_agent_snapshot("JOB_ID", event.artifact.snapshot_id) # les instantanés markdown, html et text contiennent directement le contenu. # les instantanés json sont encodés en JSON : il faut donc les décoder. content = json.loads(snapshot.snapshot) if kind == "json" else snapshot.snapshot print(kind, event.artifact.path, content) ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" }); const trace = await firecrawl.getAgentTrace("JOB_ID"); for (const event of trace.events ?? []) { if (event.type !== "artifact.updated") continue; const kind = event.artifact.kind; if (!["markdown", "html", "json"].includes(kind)) continue; const snapshot = await firecrawl.getAgentSnapshot("JOB_ID", event.artifact.snapshotId); // les instantanés markdown, html et text contiennent directement le contenu. // les instantanés json sont encodés en JSON : il faut donc les décoder. const content = kind === "json" ? JSON.parse(snapshot.snapshot) : snapshot.snapshot; console.log(kind, event.artifact.path, content); } ``` ```bash cURL theme={null} # Récupère tous les artifacts markdown, html ou json produits par l'exécution. curl -s "https://api.firecrawl.dev/v2/agent/JOB_ID/trace" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" \ | jq -r '.events[] | select(.type == "artifact.updated") | select(.artifact.kind == "markdown" or .artifact.kind == "html" or .artifact.kind == "json") | "\(.artifact.kind) \(.artifact.snapshotId)"' \ | while read -r kind snapshot_id; do body=$(curl -s "https://api.firecrawl.dev/v2/agent/JOB_ID/snapshots/$snapshot_id" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY") # les instantanés markdown et html contiennent directement le content ; le json est encodé en JSON. if [ "$kind" = "json" ]; then printf '%s' "$body" | jq -r '.snapshot | fromjson' else printf '%s' "$body" | jq -r '.snapshot' fi done ``` Deux points à connaître avant de vous appuyer sur ces données : * **Les artefacts constituent la sortie de l'exécution, et non une archive page par page.** Ce qu'une exécution écrit dans un artefact dépend de la manière dont il traite votre prompt. Considérez donc l'ensemble des artefacts comme ce que cette exécution précise a produit, plutôt que comme un enregistrement garanti de chaque page qu'elle a ouverte. * **Les résultats des outils contiennent le reste.** Chaque événement `tool_call.finished` inclut un champ `result` contenant ce que l'outil a renvoyé ; c'est là que figure le contenu qui n'a jamais été enregistré dans un artefact.
## Partager des exécutions d’agent
Vous pouvez partager des exécutions d’agent directement depuis l’Agent Playground. Les liens partagés sont publics — toute personne disposant du lien peut consulter les résultats et l’activité de l’exécution — et vous pouvez révoquer l’accès à tout moment pour désactiver le lien. Les pages partagées ne sont pas indexées par les moteurs de recherche.
## Sélection du modèle
Firecrawl Agent utilise **Spark 2** — moins coûteux et plus rapide que les précédents modèles Spark 1, pour une précision comparable. Il s’agit du modèle par défaut : chaque exécution utilise `spark-2`, que vous définissiez ou non le paramètre `model`. **Les modèles Spark 1 sont obsolètes.** Leurs noms restent acceptés pour assurer la rétrocompatibilité, mais les requêtes qui les utilisent sont redirigées vers `spark-2`.
### Spark 2
`spark-2` couvre l’ensemble des tâches qui nécessitaient auparavant de choisir entre Mini et Pro, sans compromis entre précision et coût. **Points forts :** * Coût par exécution minimal * Durée d’exécution la plus courte * Précision comparable à celle de l’ancien modèle phare Spark 1 * Le seul modèle doté d’un budget de raisonnement : passez `effort` (`low`, `medium` ou `high`) pour contrôler l’effort de raisonnement
### Définir le modèle
Le paramètre `model` est facultatif : chaque requête utilise `spark-2` : ```python Python theme={null} from firecrawl import Firecrawl app = Firecrawl(api_key="fc-YOUR_API_KEY") # Spark 2 est le modèle par défaut — toutes les exécutions l'utilisent result = app.agent( prompt="Find the pricing of Firecrawl", model="spark-2" ) # Déprécié : les noms de modèles Spark 1 sont toujours acceptés, mais redirigés vers "spark-2". print(result.data) ``` ```js Node theme={null} import { Firecrawl } from 'firecrawl'; const firecrawl = new Firecrawl({ apiKey: "fc-YOUR_API_KEY" }); // Spark 2 est la valeur par défaut — toutes les exécutions l'utilisent const result = await firecrawl.agent({ prompt: "Find the pricing of Firecrawl", model: "spark-2" }); // Déprécié : les noms de modèles Spark 1 sont toujours acceptés, mais redirigés vers "spark-2". console.log(result.data); ``` ```bash cURL theme={null} # Spark 2 est la valeur par défaut — toutes les exécutions passent par ce modèle curl -X POST "https://api.firecrawl.dev/v2/agent" \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "prompt": "Find the pricing of Firecrawl", "model": "spark-2" }' # Obsolète : les noms de modèle Spark 1 sont toujours acceptés, mais redirigent vers "spark-2". ```
## Paramètres
| Paramètre | Type | Requis | Description | | ----------------------- | ------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `prompt` | string | **Oui** | Description en langage naturel des données que vous souhaitez extraire (max. 10 000 caractères) | | `model` | string | Non | `spark-2` est le modèle utilisé par défaut pour chaque exécution. Les modèles Spark 1 sont obsolètes et redirigés vers `spark-2` | | `effort` | string | Non | Budget de raisonnement : `low`, `medium` ou `high`. Chaque exécution est effectuée sur `spark-2`, donc `effort` peut être envoyé avec ou sans `model` | | `urls` | array | Non | Liste optionnelle d’URL sur lesquelles concentrer l’extraction | | `schema` | object | Non | Schéma JSON optionnel pour une sortie structurée | | `strictConstrainToURLs` | boolean | Non | Si `true`, l’agent visite uniquement les URL fournies dans le tableau `urls` | | `webhook` | object | Non | Webhook pour recevoir les événements du cycle de vie de l’agent (`agent.started`, `agent.action`, `agent.completed`, `agent.failed`, `agent.cancelled`). Consultez les [charges utiles de webhook](/fr/api-reference/endpoint/webhook-agent-started) | | `maxCredits` | number | Non | Nombre maximal de crédits à dépenser pour cette tâche d’agent. La valeur par défaut est **2 500** s’il n’est pas défini. Le tableau de bord prend en charge des valeurs jusqu’à **2 500** ; pour des limites plus élevées, définissez `maxCredits` via l’API (les valeurs supérieures à 2 500 sont toujours traitées comme des requêtes payantes). Si la limite est atteinte, la tâche échoue et **aucune donnée n’est renvoyée**. Les exécutions en échec ne sont pas facturées : les crédits utilisés pour le raisonnement de l’IA ne sont jamais facturés en cas d’échec, tous les crédits utilisés pour les appels d’outils pendant l’exécution (scraping, recherche, mapping, etc.) sont remboursés, et la réponse indique `creditsUsed: 0`. |
## Agent vs Extract : ce qui a été amélioré
| Fonctionnalité | Agent (nouveau) | Extract | | ------------------------ | --------------- | -------- | | URL requises | Non | Oui | | Vitesse | Plus rapide | Standard | | Coût | Inférieur | Standard | | Fiabilité | Supérieure | Standard | | Flexibilité des requêtes | Élevée | Modérée |
## Exemples de cas d'utilisation
* **Recherche** : "Trouver les 5 principales startups d'IA et les montants de leurs financements" * **Analyse concurrentielle** : "Comparer les offres tarifaires entre Slack et Microsoft Teams" * **Collecte de données** : "Extraire les informations de contact depuis les sites web d'entreprises" * **Synthèse de contenu** : "Résumer les derniers articles de blog sur le web scraping"
## Téléversement de CSV dans l’Agent Playground
L’[Agent Playground](https://www.firecrawl.dev/app/agent) prend en charge le téléversement de fichiers CSV pour le traitement par lots. Votre fichier CSV peut contenir une ou plusieurs colonnes de données d’entrée. Par exemple, une seule colonne de noms d’entreprises, ou plusieurs colonnes comme le nom de l’entreprise, le produit et l’URL du site Web. Chaque ligne représente un élément que l’agent doit traiter. Téléversez votre fichier CSV, puis ajoutez des colonnes de sortie à l’aide du bouton "+" dans l’en-tête de la grille. Chaque colonne a son propre prompt — cliquez sur l’en-tête d’une colonne pour décrire ce que l’agent doit trouver pour ce champ (p. ex., "Nom du PDG ou du fondateur", "Montant total des financements levés"). Cliquez sur Run, et l’agent traite chaque ligne en parallèle en renseignant les résultats.
## Dépannage avec Ask
Si les tâches d’agent de votre agent échouent ou renvoient des résultats inattendus, utilisez l’[API Ask](/fr/features/ask) pour un débogage assisté par agent. Décrivez le problème et obtenez une réponse vérifiée, accompagnée de paramètres de correction que vous pouvez appliquer directement : ```bash theme={null} curl -X POST https://api.firecrawl.dev/v2/support/ask \ -H "Authorization: Bearer fc-YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "question": "my agent returned incomplete results" }' ``` Consultez la [documentation Ask](/fr/features/ask) pour plus de détails et des exemples d’intégration.
## Référence de l'API
Consultez la [Référence de l'API Agent](/fr/api-reference/endpoint/agent) pour plus de détails. Vous avez des commentaires ou besoin d'aide ? Envoyez un e-mail à [help@firecrawl.com](mailto:help@firecrawl.com).
## Tarification
Firecrawl Agent utilise une **facturation dynamique** qui s’adapte à la complexité de votre demande d’extraction de données. Vous payez en fonction du travail réellement effectué par Firecrawl Agent, ce qui garantit une tarification équitable, que vous extrayiez des données simples ou des informations structurées complexes provenant de plusieurs sources.
### Fonctionnement de la tarification de l’agent
La tarification de l’agent est **dynamique et basée sur les crédits** pendant la Research Preview : * **Les extractions simples** (comme les informations de contact à partir d'une seule page) consomment généralement moins de crédits et coûtent moins cher * **Les tâches de recherche complexes** (comme une analyse concurrentielle sur plusieurs domaines) consomment plus de crédits mais reflètent mieux l’effort total requis * **Une transparence totale sur l’utilisation** vous montre exactement combien de crédits chaque requête a consommé * **La conversion de crédits** convertit automatiquement l'utilisation de crédits par l’agent en crédits pour une facturation simplifiée L'utilisation de crédits varie en fonction de la complexité de votre prompt, de la quantité de données traitées et de la structure du résultat demandé. À titre indicatif, la plupart des exécutions de l’agent consomment **quelques centaines de crédits**, tandis que les tâches simples sur une seule page peuvent en utiliser moins et que les recherches complexes sur plusieurs domaines peuvent en utiliser davantage.
### Tarification des agents parallèles
Si vous exécutez plusieurs agents en parallèle avec Spark-1 Fast, les coûts sont beaucoup plus prévisibles : 10 crédits par cellule.
### Pour commencer
**Tous les utilisateurs** bénéficient de **5 exécutions gratuites par jour**, utilisables depuis le playground ou l'API, pour explorer les fonctionnalités d'Agent sans frais. L'utilisation supplémentaire est facturée en fonction de la consommation de crédits et convertie en crédits.
### Gestion des coûts
Agent peut être coûteux, mais il existe plusieurs moyens de réduire les coûts : * **Commencez par des exécutions gratuites** : utilisez vos 5 requêtes gratuites quotidiennes pour comprendre la tarification * **Définissez un paramètre `maxCredits`** : limitez vos dépenses en définissant un nombre maximal de crédits que vous êtes prêt à dépenser. Le tableau de bord plafonne cette valeur à 2 500 crédits ; pour définir une limite plus élevée, utilisez directement le paramètre `maxCredits` via l’API (remarque : les valeurs supérieures à 2 500 sont toujours facturées comme des requêtes payantes) * **Optimisez les prompts** : des prompts plus spécifiques utilisent souvent moins de crédits * **Décomposez les tâches volumineuses en exécutions plus petites** : une seule exécution d’agent renvoie environ 150-200 lignes de donnée structurée. Pour les tâches d’extraction volumineuses, répartissez-les par catégorie, région ou lot d’URL (3-5 URL par exécution), puis fusionnez les résultats. Cela permet également de maintenir chaque exécution bien en dessous de la limite `maxCredits`. * **Surveillez votre utilisation** : suivez votre consommation via le tableau de bord * **Définissez des attentes claires** : des recherches complexes couvrant plusieurs domaines utiliseront plus de crédits que de simples extractions sur une seule page Essayez Agent dès maintenant sur [firecrawl.dev/app/agent](https://www.firecrawl.dev/app/agent) pour voir comment l’utilisation des crédits évolue selon vos cas d’usage spécifiques. La tarification est susceptible d’évoluer à mesure que nous passons de la Research Preview à la disponibilité générale. Les utilisateurs actuels recevront un préavis avant toute mise à jour de la tarification. > Ê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 les instructions d’intégration automatisée.