# Interact après le scraping

> Interagissez avec une page que vous avez récupérée à l’aide d’un prompt ou en exécutant du code.

import QuickstartPython from "/snippets/fr/v2/interact/quickstart/python.mdx";
import QuickstartJS from "/snippets/fr/v2/interact/quickstart/js.mdx";
import QuickstartCURL from "/snippets/fr/v2/interact/quickstart/curl.mdx";
import QuickstartCLI from "/snippets/fr/v2/interact/quickstart/cli.mdx";
import ExecNodePython from "/snippets/fr/v2/interact/execute-node/python.mdx";
import ExecNodeJS from "/snippets/fr/v2/interact/execute-node/js.mdx";
import ExecNodeCURL from "/snippets/fr/v2/interact/execute-node/curl.mdx";
import ExecNodeCLI from "/snippets/fr/v2/interact/execute-node/cli.mdx";
import ExecPythonPython from "/snippets/fr/v2/interact/execute-python/python.mdx";
import ExecPythonJS from "/snippets/fr/v2/interact/execute-python/js.mdx";
import ExecPythonCURL from "/snippets/fr/v2/interact/execute-python/curl.mdx";
import ExecPythonCLI from "/snippets/fr/v2/interact/execute-python/cli.mdx";
import ExecBashPython from "/snippets/fr/v2/interact/execute-bash/python.mdx";
import ExecBashJS from "/snippets/fr/v2/interact/execute-bash/js.mdx";
import ExecBashCURL from "/snippets/fr/v2/interact/execute-bash/curl.mdx";
import ExecBashCLI from "/snippets/fr/v2/interact/execute-bash/cli.mdx";
import PromptPython from "/snippets/fr/v2/interact/prompt/python.mdx";
import PromptJS from "/snippets/fr/v2/interact/prompt/js.mdx";
import PromptCURL from "/snippets/fr/v2/interact/prompt/curl.mdx";
import PromptCLI from "/snippets/fr/v2/interact/prompt/cli.mdx";
import PromptFormPython from "/snippets/fr/v2/interact/prompt/python-form.mdx";
import PromptFormJS from "/snippets/fr/v2/interact/prompt/js-form.mdx";
import PromptFormCURL from "/snippets/fr/v2/interact/prompt/curl-form.mdx";
import PromptFormCLI from "/snippets/fr/v2/interact/prompt/cli-form.mdx";
import PromptNavPython from "/snippets/fr/v2/interact/prompt/python-navigate.mdx";
import PromptNavJS from "/snippets/fr/v2/interact/prompt/js-navigate.mdx";
import PromptNavCURL from "/snippets/fr/v2/interact/prompt/curl-navigate.mdx";
import PromptNavCLI from "/snippets/fr/v2/interact/prompt/cli-navigate.mdx";
import PromptOutput from "/snippets/fr/v2/interact/response/prompt-output.mdx";
import ResponseOutput from "/snippets/fr/v2/interact/response/output.mdx";
import StopPython from "/snippets/fr/v2/interact/stop/python.mdx";
import StopJS from "/snippets/fr/v2/interact/stop/js.mdx";
import StopCURL from "/snippets/fr/v2/interact/stop/curl.mdx";
import StopCLI from "/snippets/fr/v2/interact/stop/cli.mdx";
import ProfilePython from "/snippets/fr/v2/interact/profile/python.mdx";
import ProfileJS from "/snippets/fr/v2/interact/profile/js.mdx";
import ProfileCURL from "/snippets/fr/v2/interact/profile/curl.mdx";
import ProfileCLI from "/snippets/fr/v2/interact/profile/cli.mdx";
import InteractFeedbackCTA from "/snippets/fr/interact-feedback-cta.mdx";

Scrapez une page pour obtenir des données propres, puis appelez `/interact` pour commencer à effectuer des actions sur cette page : cliquer sur des boutons, remplir des formulaires, extraire du contenu dynamique ou naviguer plus en profondeur. Décrivez simplement ce que vous voulez faire, ou écrivez du code si vous avez besoin d’un contrôle total.

<InteractFeedbackCTA src="docs-interact" />

<div id="choose-the-right-interaction-model">
  ## Choisissez le bon modèle d’interaction
</div>

| Besoin                                                              | Utiliser                                    | Documentation canonique                                                                                                                                                                                                                                                                                                                              | Méthodes SDK (Node)                                                  |
| ------------------------------------------------------------------- | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
| Démarrer une session de navigateur autonome sans scraping préalable | Browser Sandbox / session Interact autonome | [Browser Sandbox](/fr/features/browser), [Créer une session de navigateur](/fr/api-reference/endpoint/browser-create), [Exécuter du code du navigateur](/fr/api-reference/endpoint/browser-execute), [Lister les sessions de navigateur](/fr/api-reference/endpoint/browser-list), [Supprimer une session de navigateur](/fr/api-reference/endpoint/browser-delete) | `browser()`, `browserExecute()`, `listBrowsers()`, `deleteBrowser()` |
| Continuer à partir d’un résultat de scraping avec `scrapeId`        | Interact après le scraping                  | [Exécuter Interact](/fr/api-reference/endpoint/scrape-execute), [Arrêter Interact](/fr/api-reference/endpoint/scrape-browser-delete)                                                                                                                                                                                                                       | `interact()`, `stopInteraction()`                                    |

Utilisez Interact lié au scraping lorsque le workflow commence par `POST /v2/scrape` et que la réponse inclut `data.metadata.scrapeId`. Utilisez Browser Sandbox lorsque vous avez besoin d’une session autonome avec son propre cycle de vie. Le Python SDK utilise les équivalents en snake&#95;case (`browser()`, `browser_execute()`, `list_browsers()`, `delete_browser()`, `interact()`, `stop_interaction()`).

<CardGroup cols={3}>
  <Card title="Prompts IA" icon="wand-magic-sparkles">
    Décrivez l’action que vous souhaitez effectuer sur la page
  </Card>

  <Card title="Exécution de code" icon="code">
    Interagissez en toute sécurité via l’exécution de code avec playwright, agent-browser
  </Card>

  <Card title="Vue en direct" icon="eye">
    Observez ou interagissez avec le Browser en temps réel via un flux intégrable
  </Card>
</CardGroup>

<div id="how-it-works">
  ## Comment ça fonctionne
</div>

1. **Scrape** une URL avec `POST /v2/scrape`. La réponse inclut un `scrapeId` dans `data.metadata.scrapeId`. Si vous souhaitez conserver l’état du navigateur, transmettez `profile` dans cette requête.
2. **Interact** en appelant `POST /v2/scrape/{scrapeId}/interact` avec un `prompt` ou du code `playwright`. Ne transmettez pas `profile` ici ; la session d’interaction hérite du profil de la tâche de scraping.
3. **Arrêtez** la session avec `DELETE /v2/scrape/{scrapeId}/interact` lorsque vous avez terminé. Pour les profils inscriptibles, les modifications sont enregistrées à l’arrêt de la session.

<div id="quick-start">
  ## Démarrage rapide
</div>

Scrapez une page, interagissez avec elle, puis arrêtez la session :

<CodeGroup>
  <QuickstartPython />

  <QuickstartJS />

  <QuickstartCURL />

  <QuickstartCLI />
</CodeGroup>

<ResponseOutput />

<div id="interact-via-prompting">
  ## Interagir par prompt
</div>

La manière la plus simple d’interagir avec une page. Décrivez ce que vous voulez en langage naturel, et l’agent cliquera, saisira du texte, fera défiler la page et extraira automatiquement les données.

<CodeGroup>
  <PromptPython />

  <PromptJS />

  <PromptCURL />

  <PromptCLI />
</CodeGroup>

La réponse inclut un champ `output` avec la réponse de l’agent :

<PromptOutput />

<div id="keep-prompts-small-and-focused">
  ### Gardez les prompts courts et ciblés
</div>

Les prompts sont plus efficaces lorsque chacun correspond à **une tâche unique et claire**. Au lieu de demander à l&#39;agent d&#39;exécuter un workflow complexe en plusieurs étapes en une seule fois, décomposez-le en appels `interact` distincts. Chaque appel réutilise la même session de navigateur, de sorte que l&#39;état est conservé d&#39;un appel à l&#39;autre.

<div id="running-code">
  ## Exécution de code
</div>

Pour un contrôle total, vous pouvez exécuter du code directement dans le sandbox du navigateur. La variable `page` (un objet Playwright Page) est disponible en Node.js et en Python. Le mode Bash inclut [agent-browser](https://github.com/vercel-labs/agent-browser) en préinstallation. Vous pouvez également prendre des captures d’écran pendant la session : utilisez `(await page.screenshot()).toString("base64")` en Node.js, `await page.screenshot(path="/tmp/screenshot.png")` en Python, ou `agent-browser screenshot` en Bash.

<div id="nodejs-playwright">
  ### Node.js (Playwright)
</div>

Le langage par défaut. Écrivez directement du code Playwright. `page` est déjà connectée au navigateur.

<CodeGroup>
  <ExecNodePython />

  <ExecNodeJS />

  <ExecNodeCURL />

  <ExecNodeCLI />
</CodeGroup>

<div id="python">
  ### Python
</div>

Définissez `language` sur `"python"` pour l’API Python de Playwright.

<CodeGroup>
  <ExecPythonPython />

  <ExecPythonJS />

  <ExecPythonCURL />

  <ExecPythonCLI />
</CodeGroup>

<div id="bash-agent-browser">
  ### Bash (agent-browser)
</div>

[agent-browser](https://github.com/vercel-labs/agent-browser) est une CLI préinstallée dans le sandbox avec plus de 60 commandes. Elle fournit un arbre d’accessibilité avec des références d’éléments (`@e1`, `@e2`, ...), ce qui est idéal pour l’automatisation pilotée par un LLM.

<CodeGroup>
  <ExecBashPython />

  <ExecBashJS />

  <ExecBashCURL />

  <ExecBashCLI />
</CodeGroup>

Commandes courantes d’agent-browser :

| Commande                  | Description                                              |
| ------------------------- | -------------------------------------------------------- |
| `snapshot`                | Arbre d’accessibilité complet avec références d’éléments |
| `snapshot -i`             | Éléments interactifs uniquement                          |
| `click @e1`               | Cliquer sur un élément par référence                     |
| `fill @e1 "text"`         | Effacer le champ et saisir du texte                      |
| `type @e1 "text"`         | Saisir sans effacer                                      |
| `press Enter`             | Appuyer sur une touche du clavier                        |
| `scroll down 500`         | Faire défiler vers le bas de 500 pixels                  |
| `get text @e1`            | obtenir le contenu du texte                              |
| `get url`                 | obtenir l’URL actuelle                                   |
| `wait @e1`                | Attendre un élément                                      |
| `wait --load networkidle` | Attendre l’inactivité du réseau                          |
| `find text "X" click`     | Trouver un élément par son texte et cliquer              |
| `screenshot`              | Prendre une capture d’écran de la page actuelle          |
| `eval "js code"`          | Exécuter du JavaScript dans la page                      |

<div id="live-view">
  ## Vue en direct
</div>

Chaque réponse Interact renvoie un `liveViewUrl` que vous pouvez intégrer pour voir le navigateur en temps réel. Utile pour le débogage, les démonstrations ou la création d’interfaces pilotées par le navigateur.

```json Response
{
  "success": true,
  "cdpUrl": "wss://browser.firecrawl.dev/...",
  "liveViewUrl": "https://liveview.firecrawl.dev/...",
  "interactiveLiveViewUrl": "https://liveview.firecrawl.dev/...",
  "stdout": "",
  "result": "...",
  "exitCode": 0
}
```

```html
<iframe src="LIVE_VIEW_URL" width="100%" height="600" />
```

<div id="interactive-live-view">
  ### Vue en direct interactive
</div>

La réponse inclut également un `interactiveLiveViewUrl`. Contrairement à la vue en direct standard, qui est en lecture seule, la vue en direct interactive permet aux utilisateurs de cliquer, de saisir du texte et d’interagir directement avec la session du navigateur via le flux intégré. Cela est utile pour créer des interfaces de navigateur destinées aux utilisateurs, par exemple pour des parcours de connexion ou des workflows guidés dans lesquels les utilisateurs finaux doivent contrôler le navigateur.

```html
<iframe src="INTERACTIVE_LIVE_VIEW_URL" width="100%" height="600" />
```

<div id="cdp-url">
  ### URL CDP
</div>

Chaque réponse Interact renvoie également un `cdpUrl` : l’URL WebSocket brute du protocole Chrome DevTools Protocol (CDP) pour la session de navigateur. Utilisez-la pour vous connecter directement à la session en cours depuis Playwright, Puppeteer ou n’importe quel client CDP, et piloter le navigateur avec votre propre code.

```js
import { chromium } from "playwright";

const browser = await chromium.connectOverCDP(cdpUrl);
const context = browser.contexts()[0];
const page = context.pages()[0];
```

<div id="session-lifecycle">
  ## Cycle de vie d’une session
</div>

<div id="creation">
  ### Création
</div>

Le premier appel `POST /v2/scrape/{scrapeId}/interact` poursuit la session de scrape et démarre l’interaction.

<div id="reuse">
  ### Réutilisation
</div>

Les appels `interact` suivants sur le même `scrapeId` réutilisent la session existante. Le navigateur reste ouvert et conserve son état entre les appels, ce qui vous permet d’enchaîner plusieurs interactions :

<CodeGroup>
  ```python Python
  # Premier appel : cliquer sur un onglet
  app.interact(scrape_id, code="await page.click('#tab-2')")

  # Deuxième appel : l'onglet est toujours sélectionné, extraire son contenu
  result = app.interact(scrape_id, code="await page.$eval('#tab-2-content', el => el.textContent)")
  print(result.result)
  ```

  ```js Node
  // Premier appel : cliquer sur un onglet
  await app.interact(scrapeId, { code: "await page.click('#tab-2')" });

  // Deuxième appel : l'onglet est toujours sélectionné, extraire son contenu
  const result = await app.interact(scrapeId, {
    code: "await page.$eval('#tab-2-content', el => el.textContent)",
  });
  console.log(result.result);
  ```

  ```bash CLI
  # Premier appel : cliquer sur un onglet
  firecrawl interact -c "await page.click('#tab-2')"

  # Deuxième appel : l'onglet est toujours sélectionné, extraire son contenu
  firecrawl interact -c "await page.\$eval('#tab-2-content', el => el.textContent)"
  ```
</CodeGroup>

<div id="cleanup">
  ### Nettoyage
</div>

Arrêtez explicitement la session une fois terminé :

<CodeGroup>
  <StopPython />

  <StopJS />

  <StopCURL />

  <StopCLI />
</CodeGroup>

Les sessions expirent également automatiquement en fonction du TTL (par défaut : 10 minutes) ou du timeout d&#39;inactivité (par défaut : 5 minutes).

<Warning>
  Arrêtez toujours les sessions une fois terminé afin d&#39;éviter une facturation inutile. Les credits sont calculés au prorata à la seconde. La facturation minimale est d&#39;une minute de browser. Les sessions qui utilisent un `prompt` sont facturées à 7 credits par minute de browser ; les sessions sans prompt sont facturées à 2. Consultez la [Facturation](/fr/billing#credit-costs-per-endpoint) pour plus de détails.
</Warning>

<div id="persistent-profiles-with-scrape-interact">
  ## Profils persistants avec Scrape + Interact
</div>

Par défaut, chaque session de scrape + interact démarre avec un navigateur propre. Avec `profile`, vous pouvez enregistrer et réutiliser l’état du navigateur (cookies, localStorage, sessions) entre plusieurs scrapes. C’est utile pour rester connecté et conserver les préférences.

Passez l’objet `profile` dans la requête initiale `POST /v2/scrape`. Ne passez pas `profile` à `POST /v2/scrape/{scrapeId}/interact` ; la session interact réutilise la session de navigateur et les paramètres de profil de la tâche de scraping. Arrêtez la session interact avec `DELETE /v2/scrape/{scrapeId}/interact` afin que les modifications apportées au profil puissent être enregistrées.

```bash cURL
curl -X POST "https://api.firecrawl.dev/v2/scrape" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com",
    "formats": ["markdown"],
    "profile": {
      "name": "my-profile",
      "saveChanges": true
    }
  }'

curl -X POST "https://api.firecrawl.dev/v2/scrape/SCRAPE_ID/interact" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Click the login button"
  }'

curl -X DELETE "https://api.firecrawl.dev/v2/scrape/SCRAPE_ID/interact" \
  -H "Authorization: Bearer fc-YOUR_API_KEY"
```

Le cycle de vie du profil est :

1. Créez le scrape avec `profile.name` et `saveChanges: true`.
2. Exécutez des interactions par prompt ou par code sur le `scrapeId` renvoyé.
3. Arrêtez la session pour enregistrer les cookies, le localStorage et les autres données d’état du navigateur.
4. Démarrez plus tard un scrape avec le même `profile.name`. Utilisez `saveChanges: false` lorsque vous voulez uniquement lire l’état existant sans réécrire les modifications.

<CodeGroup>
  <ProfilePython />

  <ProfileJS />

  <ProfileCURL />

  <ProfileCLI />
</CodeGroup>

| Paramètre     | Par défaut | Description                                                                                                                                                                                                                                                 |
| ------------- | ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name`        | None       | Nom du profil persistant. Les scrapes portant le même nom partagent l’état du navigateur.                                                                                                                                                                   |
| `saveChanges` | `true`     | Lorsque `true`, l’état du navigateur est réenregistré dans le profil à l’arrêt de la session interact. Définissez `false` pour charger des données existantes sans les écrire, ce qui est utile lorsque vous avez besoin de plusieurs lecteurs concurrents. |

<Note>
  Une seule session peut enregistrer dans un profil à la fois. Si une autre session enregistre déjà, vous recevrez une erreur `409`. Vous pouvez quand même ouvrir le même profil avec `saveChanges: false`, ou réessayer plus tard.
</Note>

L’état du navigateur est enregistré lorsque la session interact est arrêtée. Arrêtez toujours la session une fois terminé afin que le profil puisse être réutilisé.

<div id="validate-persistence">
  ### Vérifier la persistance
</div>

Vous pouvez tester la persistance sans dépendre d’une véritable procédure de connexion en écrivant une valeur dans `localStorage` lors d’une session, en l’arrêtant, puis en lisant cette valeur dans une seconde session avec le même profil.

```bash cURL
# Session 1 : écrire l'état du navigateur et le sauvegarder
RESPONSE=$(curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
  -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com",
    "formats": ["markdown"],
    "profile": { "name": "profile-validation", "saveChanges": true }
  }')

SCRAPE_ID=$(echo "$RESPONSE" | jq -r ".data.metadata.scrapeId")

curl -s -X POST "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
  -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "code": "await page.evaluate(() => { localStorage.setItem(\"firecrawlProfileCheck\", \"saved\"); document.cookie = \"firecrawl_profile_check=saved; path=/; max-age=3600\"; return localStorage.getItem(\"firecrawlProfileCheck\"); });"
  }'

curl -s -X DELETE "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
  -H "Authorization: Bearer $FIRECRAWL_API_KEY"

# Session 2 : charger le même profil en mode lecture seule et vérifier la valeur
RESPONSE=$(curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
  -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com",
    "formats": ["markdown"],
    "profile": { "name": "profile-validation", "saveChanges": false }
  }')

SCRAPE_ID=$(echo "$RESPONSE" | jq -r ".data.metadata.scrapeId")

curl -s -X POST "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
  -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "code": "await page.evaluate(() => ({ localStorage: localStorage.getItem(\"firecrawlProfileCheck\"), cookie: document.cookie.includes(\"firecrawl_profile_check=saved\") }));"
  }'

curl -s -X DELETE "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
  -H "Authorization: Bearer $FIRECRAWL_API_KEY"
```

La deuxième réponse Interact devrait afficher `localStorage` avec la valeur `"saved"` et `cookie` avec la valeur `true`.

<Info>
  Les profils créés via l’API peuvent ne pas encore apparaître dans Dashboard &gt; Interact &gt; Profiles. Le dashboard ne fournit pas encore un inventaire complet des profils persistants créés via l’API.
</Info>

<div id="when-to-use-what">
  ## Quand utiliser chaque option
</div>

| Cas d’usage                                       | Recommandé                    | Pourquoi                                     |
| ------------------------------------------------- | ----------------------------- | -------------------------------------------- |
| Recherche web                                     | [Recherche](/fr/features/search) | Point de terminaison de recherche dédié      |
| Obtenir du contenu propre depuis une URL          | [Scrape](/fr/features/scrape)    | Un seul appel API, aucune session nécessaire |
| Cliquer, saisir, naviguer sur une page            | **Interact** (prompt)         | Décrivez simplement l’action en anglais      |
| Extraire des données nécessitant des interactions | **Interact** (prompt)         | Aucun sélecteur nécessaire                   |
| Logique de scraping complexe                      | **Interact** (code)           | Contrôle total avec Playwright               |

<Info>
  **Interact vs Browser Sandbox** : Interact repose sur la même infrastructure que [Browser Sandbox](/fr/features/browser), mais offre une meilleure interface pour le cas le plus courant : scraper une page, puis aller plus loin. Browser Sandbox est préférable lorsque vous avez besoin d’une session de navigateur autonome qui n’est pas liée à un scraping spécifique.
</Info>

<div id="pricing">
  ## Tarification
</div>

* **Code uniquement** (sans `prompt`): 2 credits par minute de session
* **Avec des prompts IA**: 7 credits par minute de session
* **Scrape**: facturé séparément (1 credit par scrape, plus les coûts spécifiques au format)

<div id="api-reference">
  ## Référence de l’API
</div>

* [Exécuter Interact](/fr/api-reference/endpoint/scrape-execute): `POST /v2/scrape/{scrapeId}/interact`
* [Arrêter Interact](/fr/api-reference/endpoint/scrape-browser-delete): `DELETE /v2/scrape/{scrapeId}/interact`

<div id="request-body-post">
  ### Corps de la requête (POST)
</div>

| Champ      | Type     | Par défaut | Description                                                                                                      |
| ---------- | -------- | ---------- | ---------------------------------------------------------------------------------------------------------------- |
| `prompt`   | `string` | Aucune     | Tâche en langage naturel pour l’agent d’IA. Obligatoire si `code` n’est pas défini. Maximum 10 000 caractères.   |
| `code`     | `string` | Aucune     | Code à exécuter (Node.js, Python ou Bash). Obligatoire si `prompt` n’est pas défini. Maximum 100 000 caractères. |
| `language` | `string` | `"node"`   | `"node"`, `"python"` ou `"bash"`. Utilisé uniquement avec `code`.                                                |
| `timeout`  | `number` | `30`       | timeout en secondes (1–300).                                                                                     |
| `origin`   | `string` | Aucune     | Identifiant de l’appelant pour le suivi de l’activité.                                                           |

<div id="response">
  ### Réponse
</div>

| Champ                    | Description                                                                                                                                                               |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `success`                | `true` si l’exécution s’est terminée sans erreur                                                                                                                          |
| `cdpUrl`                 | URL WebSocket brute du Chrome DevTools Protocol (CDP) pour la session de navigateur. Connectez-vous directement avec Playwright, Puppeteer ou n’importe quel client CDP  |
| `liveViewUrl`            | URL de la vue en direct en lecture seule pour la session de navigateur                                                                                                    |
| `interactiveLiveViewUrl` | URL de la vue en direct interactive (les utilisateurs peuvent contrôler le navigateur)                                                                                    |
| `output`                 | La réponse en langage naturel de l’agent à votre `prompt`. Présent uniquement lors de l’utilisation de `prompt`.                                                          |
| `stdout`                 | Sortie standard de l’exécution du code                                                                                                                                    |
| `result`                 | Valeur de retour brute du sandbox. Pour `code` : la dernière expression évaluée. Pour `prompt` : l’instantané brut de la page utilisé par l’agent pour produire `output`. |
| `stderr`                 | Sortie d’erreur standard                                                                                                                                                  |
| `exitCode`               | Code de sortie (`0` = succès)                                                                                                                                             |
| `killed`                 | `true` si l’exécution a été interrompue en raison d’un timeout                                                                                                            |

***

Vous avez des retours ou besoin d’aide ? Envoyez un e-mail à [help@firecrawl.com](mailto:help@firecrawl.com) ou contactez-nous sur [Discord](https://discord.gg/firecrawl).