> ## Documentation Index
> Fetch the complete documentation index at: https://student-213fb9fc.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Bac à sable navigateur

> Lancez des sessions de navigateur en bac à sable et exécutez à distance du Python, du JavaScript ou du bash via agent-browser, l'API, la CLI, les SDK et MCP.

Le Firecrawl Browser Sandbox offre à vos agents un environnement de navigateur sécurisé et entièrement géré. Aucune configuration locale, aucune installation de Chromium, aucun problème de compatibilité de pilotes. agent-browser et Playwright sont préinstallés. Chaque session s’exécute dans un bac à sable isolé et éphémère, qui monte en charge sans avoir à gérer d’infrastructure.

Disponible via l’[API](/fr/api-reference/endpoint/browser-create), la [CLI](/fr/sdks/cli#browser) (Bash / agent-browser, Python, Node), le [SDK Node](/fr/sdks/node#browser), le [SDK Python](/fr/sdks/python#browser), le [Vercel AI SDK](/fr/developer-guides/llm-sdks-and-frameworks/vercel-ai-sdk) et le [serveur MCP](/fr/mcp-server).

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

```bash theme={null}
npx -y firecrawl-cli@latest init --all --browser
```

Vous pouvez également installer la CLI Firecrawl ou laisser l’agent l’installer pour vous comme ci-dessus :

```bash theme={null}
npm install -g firecrawl-cli
```

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

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

<CodeGroup>
  ```js Node theme={null}
  // npm install @mendable/firecrawl-js
  import Firecrawl from '@mendable/firecrawl-js';

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

  // 1. Lancer une 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);
  ```

  ```python Python theme={null}
  # 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)
  ```

  ```bash CLI theme={null}
  # 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
  ```

  ```bash cURL theme={null}
  # 1. Lancer une session
  curl -X POST "https://api.firecrawl.dev/v2/browser" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
    -H "Content-Type: application/json"

  # 2. Execute code
  curl -X POST "https://api.firecrawl.dev/v2/browser/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/browser/YOUR_SESSION_ID" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY"
  ```
</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 40 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
</div>

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

<CodeGroup>
  ```js Node theme={null}
  import Firecrawl from '@mendable/firecrawl-js';

  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/...
  ```

  ```python Python theme={null}
  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/...
  ```

  ```bash CLI theme={null}
  # 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
  ```

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

```json Response theme={null}
{
  "success": true,
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "cdpUrl": "wss://cdp-proxy.firecrawl.dev/cdp/550e8400-e29b-41d4-a716-446655440000",
  "liveViewUrl": "https://liveview.firecrawl.dev/550e8400-e29b-41d4-a716-446655440000",
  "interactiveLiveViewUrl": "https://liveview.firecrawl.dev/550e8400-e29b-41d4-a716-446655440000?interactive=true"
}
```

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

<CodeGroup>
  ```js Node theme={null}
  import Firecrawl from '@mendable/firecrawl-js';

  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);
  ```

  ```python Python theme={null}
  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)
  ```

  ```bash CLI theme={null}
  # 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"
  ```

  ```bash cURL theme={null}
  # Exécuter du code Python Playwright
  curl -X POST "https://api.firecrawl.dev/v2/browser/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/browser/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"
    }'
  ```
</CodeGroup>

```json Response theme={null}
{
  "success": true,
  "result": "Example Domain"
}
```

<div id="agent-browser-bash-mode">
  ## 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.

<div id="shorthand">
  ### 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 theme={null}
firecrawl browser "open https://example.com"
firecrawl browser "snapshot"
firecrawl browser "click @e5"
```

<div id="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>
  ```bash Navigation & capture theme={null}
  firecrawl browser execute "open https://example.com"
  firecrawl browser execute "snapshot"
  ```

  ```bash Interaction theme={null}
  firecrawl browser execute "click @e5"
  firecrawl browser execute "fill @e3 'search query'"
  firecrawl browser execute "scrape"
  ```
</CodeGroup>

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

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

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

  ```javascript Node theme={null}
  const result = await app.browserExecute(sessionId, {
    code: "agent-browser snapshot",
    language: "bash",
  });
  ```

  ```python Python theme={null}
  result = app.browser_execute(
      session_id,
      code="agent-browser snapshot",
      language="bash",
  )
  ```
</CodeGroup>

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

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

Par défaut, chaque session de navigateur commence avec un état vierge. Avec `profile`, vous pouvez enregistrer et réutiliser l'état du navigateur entre les sessions. C'est pratique 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>
  ```js Node theme={null}
  const session = await firecrawl.browser({
    ttl: 300,
    profile: {
      name: "my-profile",
      saveChanges: true,
    },
  });
  ```

  ```python Python theme={null}
  session = app.browser(
      ttl=300,
      profile={
          "name": "my-profile",
          "save_changes": True,
      },
  )
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.firecrawl.dev/v2/browser" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "ttl": 300,
      "profile": {
        "name": "my-profile",
        "saveChanges": true
      }
    }'
  ```

  ```bash CLI theme={null}
  # 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"
  ```
</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 fermeture. Définissez `false` pour charger les données existantes sans écriture — utile lorsque vous avez besoin de plusieurs lecteurs en parallèle. |

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

L'état de la session de navigateur n'est enregistré qu'à la fermeture de la session. Nous vous recommandons donc de fermer la session de navigateur lorsque vous avez terminé afin qu'elle puisse être réutilisée. Pour l'enregistrer et la fermer :

<CodeGroup>
  ```js Node theme={null}
  import Firecrawl from '@mendable/firecrawl-js';

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

  await firecrawl.deleteBrowser("YOUR_SESSION_ID");
  ```

  ```python Python theme={null}
  from firecrawl import Firecrawl

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

  app.delete_browser("YOUR_SESSION_ID")
  ```

  ```bash CLI theme={null}
  # Fermer la session active
  firecrawl browser close

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

  ```bash cURL theme={null}
  curl -X DELETE "https://api.firecrawl.dev/v2/browser" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"id": "YOUR_SESSION_ID"}'
  ```
</CodeGroup>

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

<CodeGroup>
  ```js Node theme={null}
  import Firecrawl from '@mendable/firecrawl-js';

  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);
  ```

  ```python Python theme={null}
  from firecrawl import Firecrawl

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

  response = app.list_browsers()
  print(response.sessions)
  ```

  ```bash CLI theme={null}
  firecrawl browser list
  firecrawl browser list active
  ```

  ```bash cURL theme={null}
  curl -X GET "https://api.firecrawl.dev/v2/browser" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY"

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

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

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

Les sessions ont deux paramètres de TTL :

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

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

<CodeGroup>
  ```js Node theme={null}
  import Firecrawl from '@mendable/firecrawl-js';

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

  await firecrawl.deleteBrowser("YOUR_SESSION_ID");
  ```

  ```python Python theme={null}
  from firecrawl import Firecrawl

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

  app.delete_browser("YOUR_SESSION_ID")
  ```

  ```bash CLI theme={null}
  # Fermer la session active
  firecrawl browser close

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

  ```bash cURL theme={null}
  curl -X DELETE "https://api.firecrawl.dev/v2/browser" \
    -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"id": "YOUR_SESSION_ID"}'
  ```
</CodeGroup>

<div id="live-view">
  ## 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 Response theme={null}
{
  "success": true,
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "cdpUrl": "wss://cdp-proxy.firecrawl.dev/cdp/550e8400-...",
  "liveViewUrl": "https://liveview.firecrawl.dev/550e8400-...",
  "interactiveLiveViewUrl": "https://liveview.firecrawl.dev/550e8400-...?interactive=true"
}
```

```html theme={null}
<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 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 theme={null}
<iframe src="INTERACTIVE_LIVE_VIEW_URL" width="100%" height="600" />
```

<div id="connecting-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>
  ```typescript TypeScript theme={null}
  import Firecrawl from '@mendable/firecrawl-js';
  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);
  ```

  ```python Python theme={null}
  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)
  ```

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

<div id="when-to-use-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
</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
</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
</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
</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/gSmWdAkdwd).