# Administración de sesiones de navegador
## Iniciar una sesión de navegador
Tras crear un navegador, puede iniciar una sesión para interactuar con las aplicaciones web.
**Example**
1. Para iniciar una sesión de navegador mediante la AWS CLI, utilice el `start-browser-session` comando:
```
aws bedrock-agentcore start-browser-session \
--region \
--browser-identifier "my-browser" \
--name "my-browser-session" \
--session-timeout-seconds 900 \
--view-port width=1456,height=819
```
1. Para iniciar una sesión de navegador con el AWS SDK para Python (Boto3), usa el método: `start_browser_session`
**Sintaxis de la solicitud**
A continuación se muestra la sintaxis de la solicitud:
```
response = dp_client.start_browser_session(
browserIdentifier="aws.browser.v1",
name="browser-session-1",
sessionTimeoutSeconds=3600,
viewPort={
'height': 819,
'width': 1456
}
)
```
1. Para iniciar una sesión de navegador con la BrowserClient clase para tener más control sobre el ciclo de vida de la sesión:
```
from bedrock_agentcore.tools.browser_client import BrowserClient
# Create a browser client
client = BrowserClient(region="us-west-2")
# Start a browser session
client.start()
print(f"Session ID: {client.session_id}")
try:
# Generate WebSocket URL and headers
url, headers = client.generate_ws_headers()
# Perform browser operations with your preferred automation tool
finally:
# Always close the session when done
client.stop()
```
1. Para crear una nueva sesión de navegador mediante la API, usa la siguiente llamada:
```
# Using awscurl
awscurl -X PUT \
"https://bedrock-agentcore..amazonaws.com/browsers/aws.browser.v1/sessions/start" \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
--service bedrock-agentcore \
--region \
-d '{
"name": "browser-session-abc12345",
"description": "browser sandbox session",
"sessionTimeoutSeconds": 300,
"viewPort": {
"height": 819,
"width": 1456
}
}'
```
## Obtenga la sesión del navegador
Puede obtener información sobre una sesión de navegador que haya creado.
**Example**
1. Para obtener información sobre una sesión de navegador mediante la AWS CLI, utilice el `get-browser-session` comando:
```
aws bedrock-agentcore get-browser-session \
--region \
--browser-identifier "aws.browser.v1" \
--session-id ""
```
1. Para obtener información sobre una sesión de navegador mediante el AWS SDK para Python (Boto3), usa el método: `get_browser_session`
**Sintaxis de la solicitud**
A continuación se muestra la sintaxis de la solicitud:
```
response = dp_client.get_browser_session(
browserIdentifier="aws.browser.v1",
sessionId=""
)
```
1. Para obtener información sobre una sesión de navegador mediante la API, utilice la siguiente llamada:
```
# Using awscurl
awscurl -X GET \
"https://bedrock-agentcore..amazonaws.com/browsers/aws.browser.v1/sessions/get?sessionId=" \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
--service bedrock-agentcore \
--region
{
"browserIdentifier": "aws.browser.v1",
"createdAt": "2025-07-14T22:16:40.713152248Z",
"lastUpdatedAt": "2025-07-14T22:16:40.713152248Z",
"name": "testBrowserSession1752531400",
"sessionId": "",
"sessionReplayArtifact": null,
"sessionTimeoutSeconds": 900,
"status": "TERMINATED",
"streams": {
"automationStream": {
"streamEndpoint": "wss://bedrock-agentcore..amazonaws.com/browser-streams/aws.browser.v1/sessions//automation",
"streamStatus": "ENABLED"
},
"liveViewStream": {
"streamEndpoint": "https://bedrock-agentcore..amazonaws.com/browser-streams/aws.browser.v1/sessions//live-view"
}
},
"viewPort": {
"height": 819,
"width": 1456
}
}
```
## Interactuar con una sesión de navegador
Una vez que haya iniciado una sesión de navegador, podrá interactuar con ella mediante la WebSocket API. También puede usar la InvokeBrowser API para un control directo a nivel del sistema operativo, incluidos los clics del ratón, la entrada del teclado y las capturas de pantalla a pantalla completa. [Para obtener más información, consulte Acción del sistema operativo del navegador.](browser-invoke.md)
**Example**
1. ====== Para interactuar con una sesión del navegador mediante la consola
1. Navegue hasta su sesión de navegador activa.
1. Utilice la interfaz del navegador para navegar a sitios web, interactuar con los elementos web y realizar otras acciones del navegador.
1. Puede ver la actividad del navegador en tiempo real a través de la función de visualización en vivo.
1. Para interactuar con una sesión del navegador mediante programación, utilice la API de WebSocket-based streaming con el siguiente formato de URL:
```
https://bedrock-agentcore..amazonaws.com/browser-streams/{browser_id}/sessions/{session_id}/automation
```
Puedes usar bibliotecas como Playwright para establecer una conexión con el navegador WebSocket y controlarlo. A continuación se muestra un ejemplo:
```
from playwright.sync_api import sync_playwright, Playwright, BrowserType
import os
import base64
from bedrock_agentcore.tools.browser_client import browser_session
def main(playwright: Playwright):
# Keep browser session alive during usage
with browser_session('us-west-2') as client:
# Generate CDP endpoint and headers
ws_url, headers = client.generate_ws_headers()
# Connect to browser using headers
chromium: BrowserType = playwright.chromium
browser = chromium.connect_over_cdp(ws_url, headers=headers)
# Use the first available context or create one
context = browser.contexts[0] if browser.contexts else browser.new_context()
page = context.pages[0] if context.pages else context.new_page()
page.goto("https://amazon.com/")
print("Navigated to Amazon")
# Create CDP session for screenshot
cdp_client = context.new_cdp_session(page)
screenshot_data = cdp_client.send("Page.captureScreenshot", {
"format": "jpeg",
"quality": 80,
"captureBeyondViewport": True
})
# Decode and save screenshot
image_data = base64.b64decode(screenshot_data['data'])
with open("screenshot.jpeg", "wb") as f:
f.write(image_data)
print("✅ Screenshot saved as screenshot.jpeg")
page.close()
browser.close()
with sync_playwright() as p:
main(p)
```
El siguiente código de ejemplo muestra cómo se puede realizar una visualización en directo mediante la API de WebSocket-based streaming.
```
https://bedrock-agentcore..amazonaws.com/browser-streams/{browser_id}/sessions/{session_id}/live-view
```
A continuación se muestra el código.
```
import time
from rich.console import Console
from bedrock_agentcore.tools.browser_client import browser_session
from browser_viewer import BrowserViewerServer
console = Console()
def main():
try:
# Step 1: Create browser session
with browser_session('us-west-2') as client:
print("\r ✅ Browser ready! ")
ws_url, headers = client.generate_ws_headers()
# Step 2: Start viewer server
console.print("\n[cyan]Step 3: Starting viewer server...[/cyan]")
viewer = BrowserViewerServer(client, port=8005)
viewer_url = viewer.start(open_browser=True)
# Keep running
while True:
time.sleep(1)
except KeyboardInterrupt:
console.print("\n\n[yellow]Shutting down...[/yellow]")
if 'client' in locals():
client.stop()
console.print("✅ Browser session terminated")
except Exception as e:
console.print(f"\n[red]Error: {e}[/red]")
import traceback
traceback.print_exc()
if __name__ == "__main__":
main()
```
## Listado de sesiones del navegador
Puede enumerar todas las sesiones de navegador activas para supervisar y gestionar sus recursos. Esto resulta útil para realizar un seguimiento de las sesiones activas, identificar las sesiones de larga duración o encontrar las sesiones que se deben detener.
**Example**
1. Para enumerar las sesiones del navegador mediante la AWS CLI, utilice el `list-browser-sessions` comando:
```
aws bedrock-agentcore list-browser-sessions \
--region \
--browser-id "" \
--max-results 10
```
También puede filtrar las sesiones por estado:
```
aws bedrock-agentcore list-browser-sessions \
--region \
--browser-id "" \
--status "READY"
```
1. Para enumerar las sesiones del navegador que utilizan el AWS SDK para Python (Boto3), usa el método: `list_browser_sessions`
**Sintaxis de la solicitud**
A continuación se muestra la sintaxis de la solicitud:
```
response = dp_client.list_browser_sessions(
browserIdentifier="aws.browser.v1"
)
```
También puede filtrar las sesiones por estado:
```
# List only active sessions
filtered_response = dp_client.list_browser_sessions(
browserIdentifier="aws.browser.v1",
status="READY"
)
# Print filtered session information
for session in filtered_response['items']:
print(f"Ready Session ID: {session['sessionId']}")
print(f"Name: {session['name']}")
print("---")
```
1. Para ver una lista de las sesiones del navegador que utilizan la API, usa la siguiente llamada:
```
# Using awscurl
awscurl -X POST \
"https://bedrock-agentcore..amazonaws.com/browsers//sessions/list" \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
--service bedrock-agentcore \
--region \
-d '{
"maxResults": 10
}'
```
También puedes filtrar las sesiones por estado:
```
# Using awscurl
awscurl -X POST \
"https://bedrock-agentcore..amazonaws.com/browsers/aws.browser.v1/sessions/list" \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
--service bedrock-agentcore \
--region \
-d '{
"maxResults": 10,
"status": "READY"
}'
```
## Detener una sesión de navegador
Cuando termine de usar una sesión de navegador, debe detenerla para liberar recursos y evitar cargos innecesarios.
**Example**
1. Para detener una sesión de navegador mediante la AWS CLI, utilice el `stop-browser-session` comando:
```
aws bedrock-agentcore stop-browser-session \
--region \
--browser-id "" \
--session-id ""
```
1. Para detener una sesión de navegador con el AWS SDK para Python (Boto3), usa el método: `stop_browser_session`
**Sintaxis de la solicitud**
A continuación, se muestra la sintaxis de la solicitud:
```
response = dp_client.stop_browser_session(
browserIdentifier="aws.browser.v1",
sessionId="",
)
```
1. Para detener una sesión de navegador mediante la API, utilice la siguiente llamada:
```
# Using awscurl
awscurl -X PUT \
"https://bedrock-agentcore..amazonaws.com/browsers/aws.browser.v1/sessions/stop?sessionId=" \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
--service bedrock-agentcore \
--region
```
## Actualización de las transmisiones del navegador
Puede actualizar las transmisiones del navegador para activar o desactivar la automatización. Esto resulta útil cuando necesita introducir información confidencial, como credenciales de inicio de sesión, que no desea que el agente vea.
**Example**
1.
```
response = dp_client.update_browser_stream(
browserIdentifier="aws.browser.v1",
sessionId="",
streamUpdate={
"automationStreamUpdate": {
"streamStatus": "DISABLED" # or "ENABLED"
}
}
)
```
1.
```
awscurl -X PUT \
"https://bedrock-agentcore..amazonaws.com/browsers/aws.browser.v1/sessions/streams/update?sessionId=" \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
--service bedrock-agentcore \
--region \
-d '{
"streamUpdate": {
"automationStreamUpdate": {
"streamStatus": "ENABLED"
}
}
}'
```
1.
```
aws bedrock-agentcore update-browser-stream \
--region \
--browser-id "" \
--session-id "" \
--stream-update automationStreamUpdate={streamStatus=ENABLED}
```