> ## Documentation Index > Fetch the complete documentation index at: https://firecrawl-locadex-parallel-t9n-main-ydzk9zxoc20klj1uk5u1gd5b.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. 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. 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** : recherche et navigue de manière autonome au plus profond des sites pour trouver vos données * **Fiable et précis** : fonctionne avec une grande variété de requêtes et de cas d’utilisation * **Plus rapide** : traite plusieurs sources en parallèle pour des résultats plus rapides

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 :

Réponse

Fournir des URL (facultatif)

Vous pouvez éventuellement fournir des URL pour cibler l’agent sur des pages spécifiques :

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).

É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

Exemple complété

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.

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.

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 : 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 : 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é : 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` :

Fournisseurs de données soumis à des conditions

Agent peut appeler des fournisseurs de données [Alexandria](/fr/features/alexandria) pendant une exécution, mais uniquement ceux dont votre équipe a accepté les conditions d'utilisation des données. Un fournisseur dont vous n'avez pas accepté les conditions n'est jamais appelé, quelle que soit la valeur de `exchange.onTermsRequired`. L'exécution se poursuit avec les fournisseurs qu'elle peut utiliser, et la réponse d'état indique ceux qu'elle a ignorés. Il n'existe aucun mode d'acceptation automatique. L'acceptation des conditions d'un fournisseur requiert toujours l'accord d'une personne, soit dans le [tableau de bord](https://www.firecrawl.dev/app/settings?tab=data-sources), soit via un appel `terms/accept` effectué par votre application une fois que son utilisateur a donné son accord explicite. Si vous créez un agent basé sur Firecrawl, il doit demander l'accord de son utilisateur avant d'appeler `terms/accept`. Une demande de données ne vaut pas consentement aux conditions d'un fournisseur. | `onTermsRequired` | Comportement | | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `skip` (par défaut) | L'exécution répond uniquement avec les fournisseurs acceptés et n'est jamais bloquée. `exchange.skippedProviders` liste les fournisseurs soumis à conditions qui auraient été utiles. | | `ask` | Identique à `skip`, mais l'exécution se termine en outre avec `exchange.requiresAction` et un `pendingApproval` de `kind: "terms"`, afin que vous puissiez consulter votre utilisateur, accepter les conditions et poursuivre le fil. | Si vous omettez `onTermsRequired` lors d'un tour ultérieur d'un fil, ce tour reprend la valeur du tour précédent. Si un tour se termine par une demande d'approbation d'appel payant (`requireApproval`), il ne propose pas d'accepter de conditions.

Champs de la réponse

Ces champs se trouvent dans l'objet `exchange` de `GET /v2/agent/{id}` : * `skippedProviders` (tous les modes) : une entrée par fournisseur soumis à l'acceptation de conditions qui aurait été utile, avec `provider`, `name`, `capability`, `adds` (ce qu'il aurait apporté), `reason: "terms_required"`, `version` (la version des conditions) et `termsUrl` (la page du tableau de bord où les accepter). * `requiresAction` (`ask` uniquement) : `type: "accept_terms"`, un `approvalId` et une liste `providers`. `approvalId` est toujours présent. Il s'agit de l'identifiant de l'approbation `terms` en attente à laquelle vous répondez en poursuivant le fil. Chaque fournisseur précise les appels `show` (`terms/show`) et `accept` (`terms/accept`) exacts à effectuer. Le `digest` de chaque fournisseur (ainsi que `accept.options.digest`) est toujours présent et peut valoir `null` si le catalogue n'en a pas publié. Dans ce cas, exécutez d'abord `terms/show` et envoyez le digest renvoyé. ```json theme={null} { "status": "completed", "exchange": { "enabled": true, "onTermsRequired": "ask", "paidCalls": 0, "creditsUsed": null, "skippedProviders": [ { "provider": "apollo", "name": "Apollo", "capability": "people/search", "adds": "verified work emails and direct phone numbers", "reason": "terms_required", "version": "F-1.0.0", "termsUrl": "https://www.firecrawl.dev/app/alexandria/apollo" } ], "requiresAction": { "type": "accept_terms", "approvalId": "0199aaaa-0000-7000-8000-000000000000", "providers": [ { "provider": "apollo", "name": "Apollo", "capability": "people/search", "version": "F-1.0.0", "digest": "", "url": "https://www.firecrawl.dev/app/alexandria/apollo", "show": { "provider": "firecrawl", "capability": "terms/show", "options": { "provider": "apollo" } }, "accept": { "provider": "firecrawl", "capability": "terms/accept", "options": { "provider": "apollo", "version": "F-1.0.0", "digest": "", "confirmed": true } } } ] } }, "pendingApproval": { "id": "0199aaaa-0000-7000-8000-000000000000", "kind": "terms", "reason": "Apollo could add verified work emails and direct phone numbers.", "calls": [], "terms": [{ "provider": "apollo", "name": "Apollo", "version": "F-1.0.0", "digest": "", "url": "https://www.firecrawl.dev/app/alexandria/apollo" }], "resolution": null } } ```

Accepter, puis continuer

En mode `ask` : 1. Présentez les conditions à votre utilisateur. Exécutez l'appel `show` du fournisseur via [`/v2/scrape`](/fr/features/alexandria) avec `alexandria`. 2. Uniquement si l'utilisateur donne explicitement son accord, exécutez son appel `accept` de la même manière. Si `accept.options.digest` vaut `null`, utilisez le digest renvoyé par `terms/show` : ```bash theme={null} curl -X POST https://api.firecrawl.dev/v2/scrape \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "alexandria": { "provider": "firecrawl", "capability": "terms/accept", "options": { "provider": "apollo", "version": "F-1.0.0", "digest": "", "confirmed": true } } }' ``` 3. Poursuivez le même fil avec `exchange.approve`. L'offre est acceptée dans son intégralité : `callIds` et `always` sont ignorés dans ce cas. Au tour suivant, ces fournisseurs servent à combler la lacune signalée par la réponse précédente, sans tout réexécuter. ```bash theme={null} curl -X POST https://api.firecrawl.dev/v2/agent \ -H "Authorization: Bearer $FIRECRAWL_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "threadId": "", "prompt": "Continue with Apollo.", "exchange": { "approve": { "approvalId": "0199aaaa-0000-7000-8000-000000000000" } } }' ``` Pour continuer sans le fournisseur, poursuivez plutôt avec `exchange.decline: { "approvalId": "..." }`. L'offre est alors refusée dans son intégralité, et ses fournisseurs ne sont plus proposés pour le reste du fil. En mode `skip`, il n'y a aucune approbation en attente à laquelle répondre. Une fois les conditions acceptées, démarrez une nouvelle exécution (ou un nouveau tour du fil) : le fournisseur est alors disponible.

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`. | | `exchange.onTermsRequired` | string | Non | Comportement à adopter lorsqu’un fournisseur de données Alexandria que l’agent utiliserait exige l’acceptation de conditions que votre équipe n’a pas encore acceptées : `skip` (par défaut) ou `ask`. Consultez [Fournisseurs de données nécessitant l’acceptation de conditions](#data-providers-that-need-terms) |

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.