# Browser Sandbox (/fr/features/browser)

<!-- agent-signals: reading_time_min: 17 · est_tokens: 9185 · updated: 2026-07-30 -->

<Info>
  Pour les workflows d’agents, utilisez [Interact](/fr/features/interact). Interact est le parcours CLI/MCP pris en charge et peut être piloté avec des prompts ou du code après un scrape ; MCP permet aussi d’ouvrir directement depuis une URL.
</Info>

| Surface         | À utiliser pour                                                                                                                                                                                           | Point d’entrée                                                                                  | Surface agent                                                   |
| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| Browser Sandbox | Sessions de navigateur autonomes pour les utilisateurs de l’API et des SDKs qui ont besoin d’un bac à sable, d’une URL CDP, d’une vue en direct ou d’une gestion persistante du cycle de vie des sessions | `POST /v2/interact`                                                                             | API et SDKs ; la commande CLI de navigateur masquée est héritée |
| Interact        | Agir sur une page scrapée ; MCP peut aussi ouvrir directement depuis une URL via le mode URL `firecrawl_interact`                                                                                         | `POST /v2/scrape/{scrapeId}/interact`, CLI `interact` après scrape, ou MCP `firecrawl_interact` | Recommandé pour les workflows d’agents CLI/MCP                  |

Firecrawl Browser Sandbox offre aux utilisateurs de l’API et des SDKs un environnement de navigateur sécurisé où les agents peuvent interagir avec le web. Remplissez des formulaires, cliquez sur des boutons, authentifiez-vous, et plus encore.
Aucune configuration locale, aucune installation de Chromium, aucun problème de compatibilité de driver. Agent browser et Playwright sont préinstallés.

Disponible via l’[API](/fr/api-reference/endpoint/browser-create), le [SDK Node](/fr/sdks/node#browser), le [SDK Python](/fr/sdks/python#browser) et le [Vercel AI SDK](/fr/developer-guides/llm-sdks-and-frameworks/vercel-ai-sdk). La commande CLI masquée `firecrawl browser` est héritée ; les workflows d’agents CLI et MCP doivent utiliser scrape + interact à la place.

Pour ajouter la prise en charge d’Interact à un agent de codage IA (Claude Code, Codex, Open Code, Cursor, etc.), installez la compétence Firecrawl :

```bash
npx -y firecrawl-cli@latest init --all --browser
```

Chaque session s’exécute dans un bac à sable isolé, jetable ou persistant, qui passe à l’échelle sans avoir à gérer d’infrastructure.

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

Créez une session, exécutez du code, puis fermez-la :

<CodeGroup>
  <CodeBlockTabs defaultValue="Node" groupId="cli+curl+node+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Node">
        Node
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="CLI">
        CLI
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="cURL">
        cURL
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Node">
      ```js  
      // npm install firecrawl
      import { Firecrawl } from 'firecrawl';

      const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });

      // 1. Launch a session
      const session = await firecrawl.browser();
      console.log(session.cdpUrl); // wss://cdp-proxy.firecrawl.dev/cdp/...

      // 2. Execute code
      const result = await firecrawl.browserExecute(session.id, {
        code: `
          await page.goto("https://news.ycombinator.com");
          const title = await page.title();
          console.log(title);
        `,
        language: "node",
      });
      console.log(result.result); // "Hacker News"

      // 3. Close
      await firecrawl.deleteBrowser(session.id);
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Python">
      ```python  
      # pip install firecrawl
      from firecrawl import Firecrawl

      app = Firecrawl(api_key="fc-YOUR-API-KEY")

      # 1. Lancer une session
      session = app.browser()
      print(session.cdp_url)  # wss://cdp-proxy.firecrawl.dev/cdp/...

      # 2. Execute code
      result = app.browser_execute(
          session.id,
          code='await page.goto("https://news.ycombinator.com")\ntitle = await page.title()\nprint(title)',
          language="python",
      )
      print(result.result)  # "Hacker News"

      # 3. Close
      app.delete_browser(session.id)
      ```
    </CodeBlockTab>

    <CodeBlockTab value="CLI">
      ```bash  
      # Installer le CLI Firecrawl
      npm install -g firecrawl-cli

      # Raccourci - lance automatiquement une session, pas besoin d'"execute"
      firecrawl browser "open https://news.ycombinator.com"
      firecrawl browser "snapshot"
      firecrawl browser "scrape"

      # Fermer une fois terminé
      firecrawl browser close
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      # 1. Lancer une session
      curl -X POST "https://api.firecrawl.dev/v2/interact" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json"

      # 2. Execute code
      curl -X POST "https://api.firecrawl.dev/v2/interact/YOUR_SESSION_ID/execute" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "code": "await page.goto(\"https://news.ycombinator.com\")\ntitle = await page.title()\nprint(title)"
        }'

      # 3. Close
      curl -X DELETE "https://api.firecrawl.dev/v2/interact/YOUR_SESSION_ID" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY"
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

* **Aucune installation de driver requise** — Pas de binaire Chromium, pas de `playwright install`, pas de problèmes de compatibilité de driver
* **Python, JavaScript & Bash** — Envoyez du code via l'API, la CLI ou le SDK et récupérez les résultats. Les trois langages s'exécutent à distance dans la sandbox
* **agent-browser** — CLI préinstallée avec plus de 60 commandes. Les agents d'IA écrivent de simples commandes bash au lieu de code Playwright
* **Playwright préinstallé** — Playwright est déjà disponible dans la sandbox. Les agents peuvent écrire du code Playwright s’ils le préfèrent.
* **Accès CDP** — Connectez votre propre instance Playwright via WebSocket lorsque vous avez besoin d’un contrôle total
* **Vue en direct** — Suivez les sessions en temps réel via une URL de flux intégrable
* **Vue en direct interactive** — Permettez aux utilisateurs d’interagir directement avec le navigateur via un flux en direct interactif intégrable

<div id="launch-a-session">
  ## Lancer une session [#lancer-une-session]
</div>

Retourne un ID de session, une URL CDP et une URL de visualisation en direct.

<CodeGroup>
  <CodeBlockTabs defaultValue="Node" groupId="cli+curl+node+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Node">
        Node
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="CLI">
        CLI
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="cURL">
        cURL
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Node">
      ```js  
      import { Firecrawl } from 'firecrawl';

      const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });

      const session = await firecrawl.browser({
        ttl: 120,
        activityTtl: 60,
      });

      console.log(session.id);
      console.log(session.cdpUrl);      // wss://cdp-proxy.firecrawl.dev/cdp/...
      console.log(session.liveViewUrl); // https://liveview.firecrawl.dev/...
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Python">
      ```python  
      from firecrawl import Firecrawl

      app = Firecrawl(api_key="fc-YOUR-API-KEY")

      session = app.browser(
          ttl=120,
          activity_ttl=60,
      )

      print(session.id)
      print(session.cdp_url)        # wss://cdp-proxy.firecrawl.dev/cdp/...
      print(session.live_view_url)  # https://liveview.firecrawl.dev/...
      ```
    </CodeBlockTab>

    <CodeBlockTab value="CLI">
      ```bash  
      # Lancer avec vue en direct et TTL personnalisé
      firecrawl browser launch-session --stream --ttl 120 --ttl-inactivity 60

      # Launch and save session info to file
      firecrawl browser launch-session -o session.json --json
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      curl -X POST "https://api.firecrawl.dev/v2/interact" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "ttl": 120,
          "activityTtl": 60
        }'
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

```json title="Response"
{
  "success": true,
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "cdpUrl": "wss://browser.firecrawl.dev/cdp/550e8400...?token=abc123...",
  "liveViewUrl": "https://liveview.firecrawl.dev/...",
  "interactiveLiveViewUrl": "https://liveview.firecrawl.dev/...",
  "expiresAt": "2025-01-15T10:40:00Z"
}
```

<div id="execute-code">
  ## Exécuter le code [#exécuter-le-code]
</div>

Exécutez du code Python, JavaScript ou bash dans votre session. Output est renvoyé via `stdout` ; pour Node.js, la valeur de la dernière expression est également disponible dans `result`.

<CodeGroup>
  <CodeBlockTabs defaultValue="Node" groupId="cli+curl+curl-bash-agent-browser-+node+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Node">
        Node
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="CLI">
        CLI
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="cURL">
        cURL
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="cURL (Bash / agent-browser)">
        cURL (Bash / agent-browser)
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Node">
      ```js  
      import { Firecrawl } from 'firecrawl';

      const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });

      const result = await firecrawl.browserExecute("YOUR_SESSION_ID", {
        code: 'await page.goto("https://example.com"); const title = await page.title(); console.log(title);',
        language: "node",
      });

      console.log(result);
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Python">
      ```python  
      from firecrawl import Firecrawl

      app = Firecrawl(api_key="fc-YOUR-API-KEY")

      result = app.browser_execute(
          "YOUR_SESSION_ID",
          code='await page.goto("https://example.com")\ntitle = await page.title()\nprint(title)',
          language="python",
      )

      print(result)
      ```
    </CodeBlockTab>

    <CodeBlockTab value="CLI">
      ```bash  
      # Commandes agent-browser (par défaut - "agent-browser" est automatiquement préfixé)
      firecrawl browser execute "open https://example.com"
      firecrawl browser execute "snapshot"
      firecrawl browser execute "scrape"

      # Execute Playwright Python code
      firecrawl browser execute --python 'await page.goto("https://example.com")
      print(await page.title())'

      # Execute Playwright JavaScript code
      firecrawl browser execute --node 'await page.goto("https://example.com"); document.title'

      # Execute arbitrary bash in the sandbox
      firecrawl browser execute --bash 'ls /tmp'

      # Target a specific session
      firecrawl browser execute --session <id> "snapshot"
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      # Exécuter du code Python Playwright
      curl -X POST "https://api.firecrawl.dev/v2/interact/YOUR_SESSION_ID/execute" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "code": "await page.goto(\"https://example.com\")\ntitle = await page.title()\nprint(title)",
          "language": "python"
        }'

      # Exécuter du code JavaScript Playwright
      curl -X POST "https://api.firecrawl.dev/v2/interact/YOUR_SESSION_ID/execute" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "code": "await page.goto(\"https://example.com\"); const title = await page.title(); console.log(title);",
          "language": "node"
        }'
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL (Bash / agent-browser)">
      ```bash  
      # Accéder à une page
      curl -X POST "https://api.firecrawl.dev/v2/interact/YOUR_SESSION_ID/execute" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{ "code": "agent-browser open https://example.com", "language": "bash" }'

      # Obtenir un instantané d'accessibilité avec les identifiants @ref
      curl -X POST "https://api.firecrawl.dev/v2/interact/YOUR_SESSION_ID/execute" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{ "code": "agent-browser snapshot", "language": "bash" }'

      # Interagir en utilisant les identifiants @ref du snapshot
      curl -X POST "https://api.firecrawl.dev/v2/interact/YOUR_SESSION_ID/execute" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{ "code": "agent-browser click @e5", "language": "bash" }'

      # Extraire le contenu de la page au format Markdown
      curl -X POST "https://api.firecrawl.dev/v2/interact/YOUR_SESSION_ID/execute" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{ "code": "agent-browser scrape", "language": "bash" }'
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

```json title="Response"
{
  "success": true,
  "stdout": "",
  "result": "Example Domain",
  "stderr": "",
  "exitCode": 0,
  "killed": false
}
```

<div id="handling-file-downloads">
  ### Gestion des téléchargements de fichiers [#gestion-des-téléchargements-de-fichiers]
</div>

Les fichiers téléchargés au cours d'une session peuvent être capturés et renvoyés en base64. Utilisez l'API de téléchargement de Playwright via le point de terminaison `execute` :

<CodeGroup>
  <CodeBlockTabs defaultValue="Python" groupId="node+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Node">
        Node
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Python">
      ```python  
      import base64

      async with page.expect_download() as download_info:
          await page.click('a#download-link')  # Cliquez sur l'élément qui déclenche le téléchargement

      download = download_info.value
      path = await download.path()

      # Facultatif : enregistrer le fichier à un emplacement connu
      # await download.save_as('/tmp/myfile.pdf')

      # Lire le contenu du fichier et l'afficher en base64
      with open(path, "rb") as f:
          content = base64.b64encode(f.read()).decode()
          print(content)
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Node">
      ```javascript  
      // Récupérer l'URL de téléchargement à partir de l'élément de lien
      const href = await page.getAttribute('a#download-link', 'href');

      // Récupérer le fichier dans le contexte du navigateur et le convertir en base64
      const b64 = await page.evaluate(async (url) => {
        const resp = await fetch(url);
        const blob = await resp.blob();
        return new Promise((resolve) => {
          const reader = new FileReader();
          reader.onloadend = () => resolve(reader.result.split(',')[1]);
          reader.readAsDataURL(blob);
        });
      }, href);

      process.stdout.write(b64);
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<Note>
  Le système de fichiers du bac à sable est éphémère : les fichiers téléchargés sont perdus à la fin de la session. Pour les conserver, lisez leur contenu pendant la session et enregistrez-le dans votre propre espace de stockage. Les profils persistants conservent l'état du navigateur (cookies, localStorage), mais pas les fichiers sur le disque.
</Note>

<div id="agent-browser-bash-mode">
  ## agent-browser (Mode Bash) [#agent-browser-mode-bash]
</div>

[agent-browser](https://github.com/vercel-labs/agent-browser) est une CLI de navigateur headless préinstallée dans chaque sandbox. Au lieu d'écrire du code Playwright, les agents envoient de simples commandes Bash. La CLI injecte automatiquement `--cdp` pour permettre à agent-browser de se connecter à votre session active.

<Note>
  Les exemples de CLI `firecrawl browser` ci-dessous concernent les sessions Browser Sandbox héritées. Pour les workflows d'agents en CLI/MCP, privilégiez `firecrawl interact` ou l'outil MCP `firecrawl_interact`.
</Note>

<div id="shorthand">
  ### Raccourci [#raccourci]
</div>

La méthode la plus rapide pour utiliser `browser`. Le raccourci et `execute` envoient tous les deux des commandes à `agent-browser` automatiquement. Le raccourci se contente d’omettre `execute` et de lancer automatiquement une session si nécessaire :

```bash
firecrawl browser "open https://example.com"
firecrawl browser "snapshot"
firecrawl browser "click @e5"
```

<div id="cli">
  ### CLI [#cli]
</div>

La forme explicite utilise `execute`. Les commandes sont envoyées automatiquement à `agent-browser` : vous n'avez pas besoin de saisir `agent-browser` ni d'utiliser `--bash` :

<CodeGroup>
  <CodeBlockTabs defaultValue="Navigation & capture" groupId="interaction+navigation-capture">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Navigation & capture">
        Navigation & capture
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Interaction">
        Interaction
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Navigation & capture">
      ```bash  
      firecrawl browser execute "open https://example.com"
      firecrawl browser execute "snapshot"
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Interaction">
      ```bash  
      firecrawl browser execute "click @e5"
      firecrawl browser execute "fill @e3 'search query'"
      firecrawl browser execute "scrape"
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<div id="api-sdk">
  ### API & SDK [#api--sdk]
</div>

Utilisez `language: "bash"` pour exécuter des commandes agent-browser via l'API ou les SDK :

<CodeGroup>
  <CodeBlockTabs defaultValue="cURL" groupId="curl+node+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="cURL">
        cURL
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Node">
        Node
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="cURL">
      ```bash  
      curl -X POST "https://api.firecrawl.dev/v2/interact/YOUR_SESSION_ID/execute" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "code": "agent-browser snapshot",
          "language": "bash"
        }'
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Node">
      ```javascript  
      const result = await app.browserExecute(sessionId, {
        code: "agent-browser snapshot",
        language: "bash",
      });
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Python">
      ```python  
      result = app.browser_execute(
          session_id,
          code="agent-browser snapshot",
          language="bash",
      )
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<div id="session-management">
  ## Gestion des sessions [#gestion-des-sessions]
</div>

<div id="persistent-sessions">
  ### Sessions persistantes [#sessions-persistantes]
</div>

Par défaut, chaque session de navigateur démarre dans un état vierge. Avec `profile`, vous pouvez enregistrer et réutiliser l’état du navigateur entre les sessions. C’est utile pour rester connecté et conserver les préférences.

Pour enregistrer ou sélectionner un profil, utilisez le paramètre `profile` lors de la création d’une session.

<CodeGroup>
  <CodeBlockTabs defaultValue="Node" groupId="cli+curl+node+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Node">
        Node
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="cURL">
        cURL
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="CLI">
        CLI
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Node">
      ```js  
      const session = await firecrawl.browser({
        ttl: 600,
        profile: {
          name: "my-profile",
          saveChanges: true,
        },
      });
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Python">
      ```python  
      session = app.browser(
          ttl=600,
          profile={
              "name": "my-profile",
              "save_changes": True,
          },
      )
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      curl -X POST "https://api.firecrawl.dev/v2/interact" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "ttl": 600,
          "profile": {
            "name": "my-profile",
            "saveChanges": true
          }
        }'
      ```
    </CodeBlockTab>

    <CodeBlockTab value="CLI">
      ```bash  
      # Lancer avec un profil (enregistre les modifications par défaut)
      firecrawl browser launch-session --profile my-profile

      # Lancer avec un profil en mode lecture seule
      firecrawl browser launch-session --profile my-profile --no-save-changes

      # Raccourci : lancer avec un profil + exécuter en une seule étape
      firecrawl browser --profile my-profile "open https://example.com"
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

| Paramètre     | Valeur par défaut | Description                                                                                                                                                                                                            |
| ------------- | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name`        | —                 | Un nom pour le profil persistant. Les sessions portant le même nom partagent le stockage.                                                                                                                              |
| `saveChanges` | `true`            | Lorsque `true`, l’état du navigateur est enregistré dans le profil à la clôture. Définissez `false` pour charger les données existantes sans écrire — utile lorsque vous avez besoin de plusieurs lecteurs simultanés. |

<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 de la session du navigateur n’est enregistré qu’une fois la session close. Nous vous recommandons donc de clore la session du navigateur lorsque vous avez terminé afin qu’elle puisse être réutilisée. Une fois une session close, son ID de session n’est plus valide — vous ne pouvez pas le réutiliser. Créez plutôt une nouvelle session avec le même nom de profil et utilisez le nouvel ID de session renvoyé dans la réponse. Pour l’enregistrer et la clore :

<CodeGroup>
  <CodeBlockTabs defaultValue="Node" groupId="cli+curl+node+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Node">
        Node
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="CLI">
        CLI
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="cURL">
        cURL
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Node">
      ```js  
      import { Firecrawl } from 'firecrawl';

      const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });

      await firecrawl.deleteBrowser("YOUR_SESSION_ID");
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Python">
      ```python  
      from firecrawl import Firecrawl

      app = Firecrawl(api_key="fc-YOUR-API-KEY")

      app.delete_browser("YOUR_SESSION_ID")
      ```
    </CodeBlockTab>

    <CodeBlockTab value="CLI">
      ```bash  
      # Fermer la session active
      firecrawl browser close

      # Fermer une session spécifique
      firecrawl browser close --session <id>
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      curl -X DELETE "https://api.firecrawl.dev/v2/interact/YOUR_SESSION_ID" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY"
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<div id="list-sessions">
  ### Lister les sessions [#lister-les-sessions]
</div>

<CodeGroup>
  <CodeBlockTabs defaultValue="Node" groupId="cli+curl+node+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Node">
        Node
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="CLI">
        CLI
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="cURL">
        cURL
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Node">
      ```js  
      import { Firecrawl } from 'firecrawl';

      const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });

      const { sessions } = await firecrawl.listBrowsers();
      console.log(sessions);

      // Filtrer par statut
      const { sessions: active } = await firecrawl.listBrowsers({ status: "active" });
      console.log(active);
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Python">
      ```python  
      from firecrawl import Firecrawl

      app = Firecrawl(api_key="fc-YOUR-API-KEY")

      response = app.list_browsers()
      print(response.sessions)
      ```
    </CodeBlockTab>

    <CodeBlockTab value="CLI">
      ```bash  
      firecrawl browser list
      firecrawl browser list active
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      curl -X GET "https://api.firecrawl.dev/v2/interact" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY"

      # Filtrer par statut
      curl -X GET "https://api.firecrawl.dev/v2/interact?status=active" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY"
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

```json title="Response"
{
  "success": true,
  "sessions": [
    {
      "id": "550e8400-e29b-41d4-a716-446655440000",
      "status": "active",
      "cdpUrl": "wss://browser.firecrawl.dev/cdp/550e8400...?token=abc123...",
      "liveViewUrl": "https://liveview.firecrawl.dev/...",
      "interactiveLiveViewUrl": "https://liveview.firecrawl.dev/...",
      "createdAt": "2025-01-15T10:30:00Z",
      "lastActivity": "2025-01-15T10:35:00Z"
    }
  ]
}
```

<div id="ttl-configuration">
  ### Configuration du TTL [#configuration-du-ttl]
</div>

Les sessions ont deux paramètres de TTL :

| Paramètre     | Valeur par défaut | Description                                       |
| ------------- | ----------------- | ------------------------------------------------- |
| `ttl`         | 600s (10 min)     | Durée de vie maximale de la session (30-3600s)    |
| `activityTtl` | 300s (5 min)      | Fermeture automatique après inactivité (10-3600s) |

<div id="close-a-session">
  ### Clore une session [#clore-une-session]
</div>

<CodeGroup>
  <CodeBlockTabs defaultValue="Node" groupId="cli+curl+node+python">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Node">
        Node
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="CLI">
        CLI
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="cURL">
        cURL
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="Node">
      ```js  
      import { Firecrawl } from 'firecrawl';

      const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });

      await firecrawl.deleteBrowser("YOUR_SESSION_ID");
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Python">
      ```python  
      from firecrawl import Firecrawl

      app = Firecrawl(api_key="fc-YOUR-API-KEY")

      app.delete_browser("YOUR_SESSION_ID")
      ```
    </CodeBlockTab>

    <CodeBlockTab value="CLI">
      ```bash  
      # Fermer la session active
      firecrawl browser close

      # Fermer une session spécifique
      firecrawl browser close --session <id>
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      curl -X DELETE "https://api.firecrawl.dev/v2/interact/YOUR_SESSION_ID" \
        -H "Authorization: Bearer $FIRECRAWL_API_KEY"
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

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

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

```json title="Response"
{
  "success": true,
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "cdpUrl": "wss://browser.firecrawl.dev/cdp/550e8400...?token=abc123...",
  "liveViewUrl": "https://liveview.firecrawl.dev/...",
  "interactiveLiveViewUrl": "https://liveview.firecrawl.dev/...",
  "expiresAt": "2025-01-15T10:40:00Z"
}
```

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

<div id="interactive-live-view">
  ### Vue en direct interactive [#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 avec la session de navigation directement via le flux intégré. C’est utile pour créer des interfaces de navigateur destinées aux utilisateurs finaux, pour le débogage collaboratif, ou pour tout scénario où la personne qui consulte la session doit contrôler le navigateur.

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

<div id="connecting-via-cdp">
  ## Connexion via CDP [#connexion-via-cdp]
</div>

Chaque session expose une URL WebSocket CDP. L’API `execute` et l’option `--bash` couvrent la plupart des cas d’utilisation, mais si vous avez besoin d’un contrôle complet en local, vous pouvez vous connecter directement.

<CodeGroup>
  <CodeBlockTabs defaultValue="TypeScript" groupId="agent-browser+python+typescript">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="TypeScript">
        TypeScript
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="Python">
        Python
      </CodeBlockTabsTrigger>

      <CodeBlockTabsTrigger value="agent-browser">
        agent-browser
      </CodeBlockTabsTrigger>
    </CodeBlockTabsList>

    <CodeBlockTab value="TypeScript">
      ```typescript  
      import { Firecrawl } from 'firecrawl';
      import { chromium } from "playwright-core";

      const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });
      const session = await firecrawl.browser();

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

      await page.goto("https://example.com");
      console.log(await page.title());

      await browser.close();
      await firecrawl.deleteBrowser(session.id);
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Python">
      ```python  
      from firecrawl import Firecrawl
      from playwright.sync_api import sync_playwright

      app = Firecrawl(api_key="fc-YOUR-API-KEY")
      session = app.browser()

      with sync_playwright() as p:
          browser = p.chromium.connect_over_cdp(session.cdp_url)
          context = browser.contexts[0]
          page = context.pages[0] if context.pages else context.new_page()

          page.goto("https://example.com")
          print(page.title())

          browser.close()

      app.delete_browser(session.id)
      ```
    </CodeBlockTab>

    <CodeBlockTab value="agent-browser">
      ```bash  
      # Utiliser le cdpUrl renvoyé par la session
      agent-browser open https://example.com --cdp "$CDP_URL"
      agent-browser snapshot --cdp "$CDP_URL"
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<div id="when-to-use-browser">
  ## Quand utiliser Browser [#quand-utiliser-browser]
</div>

| Cas d’usage                                                                       | Outil adapté                            |
| --------------------------------------------------------------------------------- | --------------------------------------- |
| Extraire le contenu d'une URL connue                                              | [Scrape](/fr/features/scrape)           |
| Rechercher sur le Web et obtenir des résultats                                    | [Search](/fr/features/search)           |
| Naviguer dans la pagination, remplir des formulaires, cliquer au fil des parcours | **Browser**                             |
| Workflows multi-étapes avec interaction                                           | **Browser**                             |
| Navigation en parallèle sur de nombreux sites                                     | **Browser** (chaque session est isolée) |

<div id="use-cases">
  ## Cas d'utilisation [#cas-dutilisation]
</div>

* **Veille concurrentielle** - Parcourir les sites concurrents, naviguer dans les formulaires et filtres de recherche, extraire les tarifs et les fonctionnalités sous forme de données structurées
* **Ingestion de base de connaissances** - Naviguer dans les centres d'aide, la documentation et les portails d'assistance qui nécessitent des clics, de la pagination ou une authentification
* **Études de marché** - Lancer des sessions de navigation parallèles pour constituer des jeux de données à partir de sites d'offres d'emploi, d'annonces immobilières ou de bases de données juridiques

<div id="pricing">
  ## Tarification [#tarification]
</div>

Tarification simple : 2 crédits par minute de navigateur. Les utilisateurs du plan gratuit disposent de 5 heures d'utilisation offertes.

<div id="rate-limits">
  ## Limites de débit [#limites-de-débit]
</div>

Pour le lancement initial, nous autorisons jusqu'à 20 sessions de navigateur concurrentes pour tous les plans.

<div id="api-reference">
  ## Référence de l'API [#référence-de-lapi]
</div>

* [Créer une session de navigateur](/fr/api-reference/endpoint/browser-create)
* [Exécuter du code dans le 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)

***

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

> Vous êtes un agent IA qui a besoin d'une API key Firecrawl ? Consultez [firecrawl.dev/agent-onboarding/SKILL.md](https://www.firecrawl.dev/agent-onboarding/SKILL.md) pour les instructions d'onboarding automatisé.