Ir al contenido principal
Español— Elegir un idioma
Menú

Gestión de autenticación y sesiones

Lección 8 de 14 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. El reto de la autenticación
  2. Inicio de sesión basado en formularios
  3. Reutilización del estado de la sesión
  4. Gestión de la verificación en dos pasos (2FA)
  5. Gestión del SSO (inicio de sesión único)
  6. Detección del estado de inicio de sesión
  7. Seguridad de las credenciales
  8. Puntos clave

Lección reescrita el 3 de noviembre de 2026 basándose en la guía Computer use de OpenAI y la documentación de autenticación de Playwright. La versión anterior incluía contraseñas y códigos 2FA directamente en el prompt enviado al modelo, incluso mediante variables de entorno, lo cual no impide su transmisión, y delegaba el inicio de sesión SSO al agente. Ahora, tu código gestiona los secretos, el estado de la sesión se guarda mediante storage_state y el SSO se realiza una única vez de forma manual. Fuentes: Computer use · Playwright, authentication.

El reto de la autenticación

La mayoría de los flujos de automatización requieren haber iniciado sesión en un servicio. Mientras tu agente permanezca en páginas públicas, todo funciona correctamente; en el momento en que necesite abrir un CRM, un back office o una bandeja de entrada de correo, se topará con un muro de inicio de sesión. Los formularios, la verificación en dos pasos (2FA), el inicio de sesión único (SSO) y las sesiones persistentes requieren tratamientos distintos, pero una norma rige para todos: el modelo nunca debe ver un secreto.

Inicio de sesión basado en formularios

La tentación es dictarle la secuencia al agente, incluyendo las credenciales:

# NO HAGAS ESTO: la contraseña va en la petición enviada a la API
task = """
Inicia sesión en el sitio:
1. Haz clic en el campo de correo y escribe: [email protected]
2. Haz clic en el campo de contraseña y escribe: MyPassword123
3. Haz clic en el botón "Iniciar sesión"
"""

Leer la contraseña desde una variable de entorno antes de insertarla en el prompt no cambia nada: sigue dejando tu infraestructura expuesta en la petición, se conserva junto con la respuesta —las respuestas se almacenan por defecto (Lección 12)— y puede filtrarse en tus registros. OpenAI recomienda mantener las credenciales fuera del texto de la página y de las capturas de pantalla. La solución es que tu código rellene el formulario de inicio de sesión con Playwright y, una vez abierta la sesión, entregue el control al agente.

import os

def log_in(page, login_url: str):
    """Inicio de sesión realizado por tu código: el modelo nunca ve la contraseña."""
    page.goto(login_url)
    page.get_by_label("Email").fill(os.environ["APP_EMAIL"])
    page.get_by_label("Password").fill(os.environ["APP_PASSWORD"])
    page.get_by_role("button", name="Log in").click()
    page.wait_for_load_state("networkidle")

Adapta las etiquetas Email y Password a tu aplicación. Este es uno de los pocos lugares del flujo donde un selector está plenamente justificado: una página de inicio de sesión rara vez cambia y los riesgos de seguridad pesan más que la flexibilidad.

Reutilización del estado de la sesión

Iniciar sesión en cada ejecución desperdicia tiempo y, en ocasiones, puede desencadenar alertas de seguridad en el lado del servicio. Playwright permite guardar el estado de un contexto —cookies, almacenamiento local, IndexedDB— en un fichero y, a continuación, crear un nuevo contexto a partir de ese fichero.

import os

def save_session(context, filepath="session.json"):
    """Guarda el estado actual de la sesión."""
    context.storage_state(path=filepath)

def new_context_with_session(browser, filepath="session.json"):
    """Crea un contexto a partir de una sesión guardada, si existe."""
    options = {"viewport": {"width": 1280, "height": 720}}
    if os.path.exists(filepath):
        options["storage_state"] = filepath
    return browser.new_context(**options)

Integrado en el flujo de trabajo, esto genera una lógica de dos pasos: partir de la sesión guardada, verificar que sigue siendo válida y solo volver a pasar por el inicio de sesión si falla. El estado se guarda de nuevo tras la tarea, porque muchos servicios renuevan su token de sesión durante el proceso.

from playwright.sync_api import sync_playwright

def authenticated_workflow(task: str, login_url: str):
    """Flujo de trabajo con reutilización de sesión."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=True)
    try:
        context = new_context_with_session(browser)
        page = context.new_page()
        page.goto(login_url)

        if is_logged_in(page):
            print("Sesión restaurada correctamente")
        else:
            log_in(page, login_url)  # tu código, no el agente
            if not is_logged_in(page):
                raise RuntimeError("Inicio de sesión imposible: verifica credenciales o 2FA")
        save_session(context)

        result = run_agent(task, page=page)
        save_session(context)  # actualiza el estado
        return result
    finally:
        browser.close()
        pw.stop()

Trata el fichero de sesión como una contraseña: Playwright advierte de que puede contener cookies y cabeceras que permiten suplantar la cuenta, y desaconseja firmemente incluirlo en el control de versiones, incluso en un repositorio privado. Almacénalo junto con tus secretos.

Gestión de la verificación en dos pasos (2FA)

El 2FA plantea un reto porque a menudo requiere intervención humana, ya sea un código SMS o una aplicación autenticadora. Precisamente ese es su propósito: está diseñado para que un autómata no pueda saltárselo por sí solo. Conviven dos enfoques según el factor utilizado, y la elección del factor al crear la cuenta de servicio determina si tu flujo puede ejecutarse sin supervisión.

TOTP automatizado

Si la cuenta usa una aplicación TOTP como Google Authenticator o Authy, el código mostrado es simplemente una función del secreto compartido y del reloj. Por tanto, tu código puede generarlo e introducirlo él mismo, sin mostrárselo al modelo.

import os

import pyotp

def enter_totp_code(page):
    """Introduce el código TOTP actual: el secreto y el código permanecen en tu código."""
    totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
    page.get_by_label("Verification code").fill(totp.now())
    page.get_by_role("button", name="Verify").click()

Reflexiona sobre lo que estás haciendo: almacenar el secreto TOTP junto con la contraseña reduce el 2FA a un único factor, ya que ambos secretos residen en el mismo lugar. Reserva este enfoque para una cuenta de servicio dedicada, con permisos limitados al mínimo estricto.

Espera manual

Los factores no automatizables, como SMS o notificaciones push, requieren una pausa explícita. El agente se detiene, un operador valida desde su teléfono y, a continuación, el bucle se reanuda donde lo dejó. Esta es una solución aceptable para un proceso lanzado manualmente, mucho menos para una tarea cron nocturna.

def wait_for_2fa(page):
    """Pausa el agente y espera la validación manual."""
    print("Se requiere 2FA. Valida manualmente y, después, pulsa Intro.")
    input("Pulsa Intro para continuar...")
    # El agente se reanuda tras la validación

Gestión del SSO (inicio de sesión único)

Los inicios de sesión SSO (Google, Microsoft, SAML) redirigen a un proveedor de identidad externo: el agente cambiaría de dominio a mitad del flujo y tendría que introducir credenciales allí. No delegues este paso en el agente. Realiza el inicio de sesión SSO una única vez, de forma manual, en un navegador visible controlado por Playwright y, después, guarda el estado de la sesión: las ejecuciones posteriores partirán de ese estado.

def manual_sso_login(login_url: str, filepath="session.json"):
    """Un humano inicia sesión en un navegador visible; se guarda la sesión."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=False)
    context = browser.new_context()
    page = context.new_page()
    page.goto(login_url)
    input("Inicia sesión en la ventana abierta y, después, pulsa Intro...")
    save_session(context, filepath)
    browser.close()
    pw.stop()

Cuando la sesión expire eventualmente, el flujo de trabajo debe detenerse y solicitar de nuevo este inicio de sesión humano. Añade esta instrucción a las directrices del agente: si se encuentra frente a una página de un proveedor de identidad, se detiene y lo notifica en lugar de intentar cualquier acción.

Detección del estado de inicio de sesión

Toda esta mecánica descansa sobre una pregunta que debes poder responder con fiabilidad: ¿hemos iniciado sesión? Una función dedicada cruza dos señales: primero la URL actual, ya que una redirección a /login es inequívoca; después, la presencia de un elemento reservado a usuarios autenticados, típicamente el menú de cuenta. La primera prueba es instantánea; la segunda cubre aplicaciones que muestran la página de inicio de sesión sin cambiar la URL.

from playwright.sync_api import TimeoutError as PlaywrightTimeoutError

def is_logged_in(page) -> bool:
    """Comprueba si la sesión está activa."""
    # Comprobación de URL
    if "/login" in page.url or "/signin" in page.url:
        return False

    # Comprobación de elemento DOM
    try:
        page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
        return True
    except PlaywrightTimeoutError:
        return False

El except apunta precisamente al agotamiento del tiempo de espera: un except: genérico también engulliría una interrupción de teclado o un error de programación real, y querrás que esos casos salten a la superficie.

Seguridad de las credenciales

«Nunca almacenes contraseñas en tu código fuente, tus prompts ni tus registros.»

— Norma fundamental de seguridad

En la práctica, esta norma se traduce en unos pocos hábitos que apenas cuestan una vez adoptados. Las credenciales viven en variables de entorno, alimentadas en desarrollo por un fichero .env que excluyes inmediatamente del control de versiones mediante .gitignore: esta omisión es una causa clásica de fugas de secretos en repositorios públicos. En producción, sustituye este fichero por un gestor de secretos, como Vault o AWS Secrets Manager, que entregue valores bajo demanda y trace los accesos. Solo tu código los lee, nunca el modelo. Planifica la rotación periódica de contraseñas y tokens de API, de modo que una fuga antigua ya no abra nada. Por último, filtra tus registros para no registrar allí datos sensibles: un agente que registra fielmente cada pulsación de tecla también copia lo que se le ha hecho escribir.

Puntos clave

  • El modelo nunca ve un secreto: tu código introduce la contraseña y el código 2FA con Playwright
  • Guarda el estado de la sesión con storage_state y trata ese fichero como un secreto
  • El TOTP se automatiza en el lado del código y se reserva para una cuenta de servicio con derechos limitados
  • Realiza el inicio de sesión SSO una única vez de forma manual y, después, reutiliza la sesión guardada
  • Comprueba siempre el estado de inicio de sesión antes de lanzar un flujo de trabajo