# sandbox del navegador (/es/features/browser)

<!-- agent-signals: reading_time_min: 16 · est_tokens: 8997 · updated: 2026-07-30 -->

<Info>
  Para flujos de trabajo de agentes, usa [Interact](/es/features/interact). Interact es la ruta compatible para CLI/MCP y puede controlarse mediante prompts o código después de un scraping; MCP también permite abrir directamente desde una URL.
</Info>

| Superficie            | Úsalo para                                                                                                                                                 | Punto de entrada                                                                                       | Superficie de agente                                          |
| --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------- |
| sandbox del navegador | Sesiones de navegador independientes para usuarios de API/SDK que necesitan un sandbox, URL de CDP, vista en vivo o un ciclo de vida de sesión persistente | `POST /v2/interact`                                                                                    | API y SDKs; el comando oculto de navegador en CLI es heredado |
| Interact              | Actuar sobre una página extraída; MCP también puede abrir desde una URL con el modo URL de `firecrawl_interact`                                            | `POST /v2/scrape/{scrapeId}/interact`, CLI `interact` después del scraping, o MCP `firecrawl_interact` | Recomendado para flujos de trabajo de agentes en CLI/MCP      |

El sandbox del navegador de Firecrawl ofrece a los usuarios de API y SDK un entorno de navegador seguro donde los agentes pueden interactuar con la web. Completa formularios, haz clic en botones, autentícate y mucho más.
Sin configuración local, sin instalaciones de Chromium, sin problemas de compatibilidad de controladores. Agent Browser y Playwright ya vienen preinstalados.

Disponible a través de [API](/es/api-reference/endpoint/browser-create), [Node SDK](/es/sdks/node#browser), [Python SDK](/es/sdks/python#browser) y [Vercel AI SDK](/es/developer-guides/llm-sdks-and-frameworks/vercel-ai-sdk). El comando oculto de CLI `firecrawl browser` es heredado; los flujos de agentes de CLI y MCP deben usar scrape + interact en su lugar.

Para añadir compatibilidad con Interact a un agente de programación de IA (Claude Code, Codex, Open Code, Cursor, etc.), instala la skill de Firecrawl:

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

Cada sesión se ejecuta en un sandbox aislado, desechable o persistente, que escala sin necesidad de gestionar infraestructura.

<div id="quick-start">
  ## Inicio rápido [#inicio-rápido]
</div>

Crea una sesión, ejecuta código y ciérrala:

<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. Iniciar una sesión
      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  
      # Install the Firecrawl CLI
      npm install -g firecrawl-cli

      # Forma abreviada - inicia automáticamente una sesión, no se necesita "execute"
      firecrawl browser "open https://news.ycombinator.com"
      firecrawl browser "snapshot"
      firecrawl browser "scrape"

      # Close when done
      firecrawl browser close
      ```
    </CodeBlockTab>

    <CodeBlockTab value="cURL">
      ```bash  
      # 1. Iniciar una sesión
      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>

* **Sin instalación de controladores** - Sin binario de Chromium, sin `playwright install`, sin problemas de compatibilidad de controladores
* **Python, JavaScript y Bash** - Envía código vía API, CLI o SDK y recibe los resultados. Los tres lenguajes se ejecutan de forma remota en el sandbox
* **agent-browser** - CLI preinstalada con más de 60 comandos. Los agentes de IA escriben comandos bash simples en lugar de código de Playwright
* **Playwright disponible** - Playwright viene preinstalado en el sandbox. Los agentes pueden escribir código con Playwright si lo prefieren.
* **Acceso CDP** - Conecta tu propia instancia de Playwright por WebSocket cuando necesites control completo
* **Vista en vivo** - Mira las sesiones en tiempo real mediante una URL de streaming integrable
* **Vista en vivo interactiva** - Permite que los usuarios interactúen directamente con el navegador a través de un stream interactivo integrable

<div id="launch-a-session">
  ## Iniciar una sesión [#iniciar-una-sesión]
</div>

Devuelve un ID de sesión, una URL de CDP y una URL de vista en tiempo real.

<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  
      # Iniciar con vista en vivo y TTL personalizado
      firecrawl browser launch-session --stream --ttl 120 --ttl-inactivity 60

      # Iniciar y guardar la información de sesión en un archivo
      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">
  ## Ejecutar código [#ejecutar-código]
</div>

Ejecuta código de Python, JavaScript o bash en tu sesión. La salida se devuelve a través de `stdout`; para Node.js, el valor de la última expresión también está disponible en `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  
      # comandos de agent-browser (por defecto - "agent-browser" se añade automáticamente como prefijo)
      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  
      # Ejecutar código de Playwright en Python
      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"
        }'

      # Ejecutar código de Playwright en JavaScript
      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  
      # Navegar a una página
      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" }'

      # Obtener instantánea de accesibilidad con IDs @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" }'

      # Interactuar usando los IDs @ref de la instantánea
      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" }'

      # Extraer el contenido de la página como 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">
  ### Gestión de descargas de archivos [#gestión-de-descargas-de-archivos]
</div>

Los archivos descargados dentro de una sesión se pueden capturar y devolver como base64. Usa la API de descargas de Playwright mediante el endpoint `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')  # Haz clic en el elemento que activa la descarga

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

      # Opcionalmente, guarda el archivo en una ruta conocida
      # await download.save_as('/tmp/myfile.pdf')

      # Lee el contenido del archivo y genera la salida en base64
      with open(path, "rb") as f:
          content = base64.b64encode(f.read()).decode()
          print(content)
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Node">
      ```javascript  
      // Obtén la URL de descarga del elemento de enlace
      const href = await page.getAttribute('a#download-link', 'href');

      // Recupera el archivo en el contexto del navegador y conviértelo a 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>
  El sistema de archivos del sandbox es efímero: los archivos descargados se pierden cuando termina la sesión. Para conservarlos, lee su contenido dentro de la sesión y guárdalo en tu propio almacenamiento. Los perfiles persistentes conservan el estado del navegador (`cookies`, `localStorage`), pero no los archivos en disco.
</Note>

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

[agent-browser](https://github.com/vercel-labs/agent-browser) es una CLI de navegador headless preinstalada en cada sandbox. En lugar de escribir código de Playwright, los agentes envían comandos de bash sencillos. La CLI inyecta automáticamente `--cdp` para que agent-browser se conecte a tu sesión activa.

<Note>
  Los ejemplos de la CLI `firecrawl browser` que aparecen a continuación son para sesiones heredadas del sandbox del navegador. Para flujos de trabajo de agentes con CLI/MCP, usa preferentemente `firecrawl interact` o la herramienta MCP `firecrawl_interact`.
</Note>

<div id="shorthand">
  ### Atajo [#atajo]
</div>

La forma más rápida de usar `browser`. Tanto el atajo como `execute` envían comandos a `agent-browser` automáticamente. El atajo simplemente omite `execute` y abre una sesión automáticamente si es necesario:

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

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

La forma explícita usa `execute`. Los comandos se envían automáticamente a agent-browser; no necesitas escribir `agent-browser` ni usar `--bash`:

<CodeGroup>
  <CodeBlockTabs defaultValue="Navegar y capturar instantánea" groupId="interactuar+navegar-y-capturar-instant-nea">
    <CodeBlockTabsList>
      <CodeBlockTabsTrigger value="Navegar y capturar instantánea">
        Navegar y capturar instantánea
      </CodeBlockTabsTrigger>

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

    <CodeBlockTab value="Navegar y capturar instantánea">
      ```bash  
      firecrawl browser execute "open https://example.com"
      firecrawl browser execute "snapshot"
      ```
    </CodeBlockTab>

    <CodeBlockTab value="Interactuar">
      ```bash  
      firecrawl browser execute "click @e5"
      firecrawl browser execute "fill @e3 'consulta de búsqueda'"
      firecrawl browser execute "scrape"
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

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

Utiliza `language: "bash"` para ejecutar comandos de agent-browser a través de la API o los 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">
  ## Gestión de sesiones [#gestión-de-sesiones]
</div>

<div id="persistent-sessions">
  ### Sesiones persistentes [#sesiones-persistentes]
</div>

De forma predeterminada, cada sesión de navegador comienza desde cero. Con `profile`, puedes guardar el estado del navegador entre sesiones. Esto es útil para seguir conectado y mantener tus preferencias.

Para guardar o seleccionar un perfil, usa el parámetro `profile` al crear una sesión.

<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  
      # Iniciar con un perfil (guarda los cambios por defecto)
      firecrawl browser launch-session --profile my-profile

      # Iniciar con un perfil en modo de solo lectura
      firecrawl browser launch-session --profile my-profile --no-save-changes

      # Forma abreviada: iniciar con perfil + ejecutar en un solo paso
      firecrawl browser --profile my-profile "open https://example.com"
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

| Parámetro     | Predeterminado | Descripción                                                                                                                                                                                                  |
| ------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `name`        | —              | Un nombre para el perfil persistente. Las sesiones con el mismo nombre comparten el almacenamiento.                                                                                                          |
| `saveChanges` | `true`         | Cuando es `true`, el estado del navegador se guarda de nuevo en el perfil al cerrarse. Establécelo en `false` para cargar datos existentes sin escribir, útil cuando necesitas varios lectores concurrentes. |

<Note>
  Solo una sesión puede guardar en un perfil a la vez. Si otra sesión ya está guardando, recibirás un error `409`. Aun así puedes abrir el mismo perfil con `saveChanges: false` o intentarlo de nuevo más tarde.
</Note>

El estado de la sesión del navegador solo se guarda cuando la sesión se cierra. Por ello, recomendamos cerrar la sesión de navegador cuando termines de usarla para que pueda reutilizarse. Una vez cerrada una sesión, su ID de sesión deja de ser válido; no puedes reutilizarlo. En su lugar, crea una nueva sesión con el mismo nombre de perfil y usa el nuevo ID de sesión devuelto en la respuesta. Para guardarla y cerrarla:

<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  
      # Cerrar la sesión activa
      firecrawl browser close

      # Cerrar una sesión específica
      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">
  ### Listar sesiones [#listar-sesiones]
</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);

      // Filtrar por estado
      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"

      # Filtrar por estado
      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">
  ### Configuración de TTL [#configuración-de-ttl]
</div>

Las sesiones tienen dos controles de TTL:

| Parámetro     | Predeterminado | Descripción                                   |
| ------------- | -------------- | --------------------------------------------- |
| `ttl`         | 600s (10 min)  | Vida útil máxima de la sesión (30-3600s)      |
| `activityTtl` | 300s (5 min)   | Cierre automático tras inactividad (10-3600s) |

<div id="close-a-session">
  ### Cerrar una sesión [#cerrar-una-sesión]
</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  
      # Cerrar la sesión activa
      firecrawl browser close

      # Cerrar una sesión específica
      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">
  ## Vista en vivo [#vista-en-vivo]
</div>

Cada sesión devuelve un `liveViewUrl` en la respuesta que puedes insertar para ver el navegador en tiempo real. Resulta útil para depuración, demostraciones o para crear interfaces de usuario basadas en el navegador.

```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">
  ### Vista interactiva en vivo [#vista-interactiva-en-vivo]
</div>

La respuesta también incluye un `interactiveLiveViewUrl`. A diferencia de la vista en vivo estándar, que solo permite observar, la vista interactiva en vivo permite a los usuarios hacer clic, escribir e interactuar con la sesión del navegador directamente a través de la transmisión incrustada. Esto es útil para crear interfaces de navegador orientadas al usuario, depuración colaborativa o cualquier escenario en el que quien la visualiza necesite controlar el navegador.

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

<div id="connecting-via-cdp">
  ## Conexión mediante CDP [#conexión-mediante-cdp]
</div>

Cada sesión expone una URL de WebSocket de CDP. La API execute y la bandera `--bash` cubren la mayoría de los casos de uso, pero si necesitas control local completo puedes conectarte directamente.

<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  
      # Use the cdpUrl from the session response
      agent-browser open https://example.com --cdp "$CDP_URL"
      agent-browser snapshot --cdp "$CDP_URL"
      ```
    </CodeBlockTab>
  </CodeBlockTabs>
</CodeGroup>

<div id="when-to-use-browser">
  ## Cuándo usar navegador [#cuándo-usar-navegador]
</div>

| Caso de uso                                                           | Herramienta adecuada                     |
| --------------------------------------------------------------------- | ---------------------------------------- |
| Extraer contenido de una URL conocida                                 | [Scrape](/es/features/scrape)            |
| Buscar en la web y obtener resultados                                 | [Search](/es/features/search)            |
| Gestionar la paginación, completar formularios y hacer clic en flujos | **navegador**                            |
| Flujos de trabajo multietapa con interacción                          | **navegador**                            |
| Navegación en paralelo en muchos sitios                               | **navegador** (cada sesión está aislada) |

<div id="use-cases">
  ## Casos de uso [#casos-de-uso]
</div>

* **Inteligencia competitiva** - Explorar sitios de la competencia, navegar por formularios de búsqueda y filtros, y extraer precios y características en datos estructurados
* **Ingesta de base de conocimientos** - Navegar por centros de ayuda, documentación y portales de soporte que requieren clics, paginación o autenticación
* **Investigación de mercado** - Iniciar sesiones de navegador en paralelo para crear conjuntos de datos a partir de bolsas de trabajo, listados inmobiliarios o bases de datos legales

<div id="pricing">
  ## Precios [#precios]
</div>

El precio es sencillo: 2 créditos por minuto de navegador. Los usuarios del plan gratuito disponen de 5 horas de uso sin coste.

<div id="rate-limits">
  ## Límites de uso [#límites-de-uso]
</div>

En el lanzamiento inicial, permitimos hasta 20 sesiones simultáneas de navegador en todos los planes.

<div id="api-reference">
  ## Referencia de la API [#referencia-de-la-api]
</div>

* [Crear sesión de navegador](/es/api-reference/endpoint/browser-create)
* [Ejecutar código en el navegador](/es/api-reference/endpoint/browser-execute)
* [Listar sesiones de navegador](/es/api-reference/endpoint/browser-list)
* [Eliminar sesión de navegador](/es/api-reference/endpoint/browser-delete)

***

¿Tienes comentarios o necesitas ayuda? Escríbenos a [help@firecrawl.com](mailto:help@firecrawl.com) o contáctanos por [Discord](https://discord.gg/firecrawl).

> ¿Eres un agente de IA que necesita una clave de API de Firecrawl? Consulta [firecrawl.dev/agent-onboarding/SKILL.md](https://www.firecrawl.dev/agent-onboarding/SKILL.md) para obtener instrucciones de incorporación automatizada.