> ## Documentation Index
> Fetch the complete documentation index at: https://firecrawl-docs-agent-transparency-gaps.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`
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
}
```
## 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.
## 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`. |
| 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 a une limite de sortie basée sur la capacité de génération du modèle sous-jacent (\~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.