Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Authenticatie en sessies beheren

Les 8 van 14 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. De authenticatie-uitdaging
  2. Inloggen via formulieren
  3. Sessiestatus hergebruiken
  4. Omgaan met tweefactorauthenticatie (2FA)
  5. Omgaan met SSO (Single Sign-On)
  6. Inlogstatus detecteren
  7. Beveiliging van inloggegevens
  8. Belangrijkste punten

Les herschreven op 3 november 2026 op basis van de gids Computer use van OpenAI en de authenticatiedocumentatie van Playwright. De vorige versie plaatste wachtwoorden en 2FA-codes direct in de prompt die naar het model werd gestuurd—ook via omgevingsvariabelen, wat doorgifte niet verhindert—en delegeerde SSO-inloggen aan de agent. Nu behandelt uw code geheimen, wordt de sessiestatus opgeslagen met storage_state, en wordt SSO eenmalig handmatig uitgevoerd. Bronnen: Computer use · Playwright, authentication.

De authenticatie-uitdaging

De meeste automatiseringsworkflows vereisen dat u bent ingelogd bij een dienst. Zolang uw agent op openbare pagina’s blijft, werkt alles prima; zodra deze een CRM, een backoffice of een e-mailinbox moet openen, botst deze tegen een inlogmuur. Formulieren, 2FA, SSO en persistente sessies vragen elk een andere aanpak, maar één regel geldt voor allemaal: het model krijgt nooit een geheim te zien.

Inloggen via formulieren

De verleiding is groot om de reeks stappen aan de agent te dicteren, inclusief inloggegevens:

# DOE DIT NIET: het wachtwoord komt terecht in het verzoek dat naar de API wordt gestuurd
task = """
Log in op de site:
1. Klik op het e-mailveld en typ: [email protected]
2. Klik op het wachtwoordveld en typ: MyPassword123
3. Klik op de knop "Log in"
"""

Het wachtwoord eerst uit een omgevingsvariabele lezen voordat u het in de prompt plakt, verandert niets: uw infrastructuur blijft het verzoek achterlaten, het wordt bewaard samen met het antwoord—antwoorden worden standaard opgeslagen (Les 12)—en het kan uitlekken naar uw logs. OpenAI raadt aan om inloggegevens uit paginatekst en screenshots te houden. De oplossing is dat uw code het inlogformulier invult met Playwright, en pas daarna de agent overneemt zodra de sessie openstaat.

import os

def log_in(page, login_url: str):
    """Inloggen uitgevoerd door uw code: het model ziet het wachtwoord nooit."""
    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")

Pas de labels Email en Password aan uw applicatie aan. Dit is een van de weinige plekken in de workflow waar een selector volledig gerechtvaardigd is: een inlogpagina verandert zelden, en de veiligheidsbelangen wegen zwaarder dan flexibiliteit.

Sessiestatus hergebruiken

Bij elke uitvoering opnieuw inloggen kost tijd en kan soms beveiligingswaarschuwingen aan de kant van de dienst activeren. Playwright kan de status van een context opslaan—cookies, lokale opslag, IndexedDB—naar een bestand, en vervolgens een nieuwe context vanuit dat bestand aanmaken.

import os

def save_session(context, filepath="session.json"):
    """Slaat de huidige sessiestatus op."""
    context.storage_state(path=filepath)

def new_context_with_session(browser, filepath="session.json"):
    """Maakt een context aan vanuit een opgeslagen sessie, als die bestaat."""
    options = {"viewport": {"width": 1280, "height": 720}}
    if os.path.exists(filepath):
        options["storage_state"] = filepath
    return browser.new_context(**options)

Geïntegreerd in de workflow ontstaat hiermee een tweestapslogica: start vanuit de opgeslagen sessie, verifieer of deze nog geldig is, en doorloop het inlogproces alleen opnieuw als dat mislukt. De status wordt na de taak opnieuw opgeslagen, omdat veel diensten onderweg hun sessietoken vernieuwen.

from playwright.sync_api import sync_playwright

def authenticated_workflow(task: str, login_url: str):
    """Workflow met sessiehergebruik."""
    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("Sessie succesvol hersteld")
        else:
            log_in(page, login_url)  # uw code, niet de agent
            if not is_logged_in(page):
                raise RuntimeError("Inloggen onmogelijk: controleer inloggegevens of 2FA")
        save_session(context)

        result = run_agent(task, page=page)
        save_session(context)  # status bijwerken
        return result
    finally:
        browser.close()
        pw.stop()

Behandel het sessiebestand als een wachtwoord: Playwright waarschuwt dat het cookies en headers kan bevatten die accountimpersonatie mogelijk maken, en raadt sterk af om het te versioneren, zelfs niet in een privérepository. Bewaar het samen met uw geheimen.

Omgaan met tweefactorauthenticatie (2FA)

2FA vormt een uitdaging omdat het vaak menselijke tussenkomst vereist, of het nu een sms-code is of een authenticator-app. Dat is precies het doel: het is ontworpen zodat een automaat het niet alleen kan omzeilen. Twee benaderingen bestaan naast elkaar, afhankelijk van de gebruikte factor, en de keuze van factor bij het aanmaken van het serviceaccount bepaalt of uw workflow onbemand kan draaien.

Geautomatiseerde TOTP

Als het account een TOTP-app gebruikt zoals Google Authenticator of Authy, is de getoonde code slechts een functie van het gedeelde geheim en de klok. Uw code kan deze daarom zelf genereren en invoeren, zonder deze aan het model te tonen.

import os

import pyotp

def enter_totp_code(page):
    """Voert de huidige TOTP-code in: het geheim en de code blijven in uw code."""
    totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
    page.get_by_label("Verification code").fill(totp.now())
    page.get_by_role("button", name="Verify").click()

Bedenk wat u doet: het TOTP-geheim opslaan naast het wachtwoord reduceert 2FA tot één factor, aangezien beide geheimen op dezelfde plek staan. Reserveer deze aanpak voor een toegewijd serviceaccount, met rechten beperkt tot het strikte minimum.

Handmatig wachten

Niet-automatiseerbare factoren, zoals sms of pushmeldingen, vereisen een expliciete pauze. De agent stopt, een operator valideert op zijn telefoon, waarna de lus daar hervat waar deze gebleven was. Dit is een aanvaardbare oplossing voor een handmatig gestart proces, veel minder voor een nachtelijke cron-job.

def wait_for_2fa(page):
    """Pauzeert de agent en wacht op handmatige validatie."""
    print("2FA vereist. Valideer handmatig en druk vervolgens op Enter.")
    input("Druk op Enter om door te gaan...")
    # De agent hervat na validatie

Omgaan met SSO (Single Sign-On)

SSO-inlogprocessen (Google, Microsoft, SAML) leiden om naar een externe identiteitsprovider: de agent zou halverwege de stroom van domein wisselen en daar inloggegevens moeten invoeren. Delegateer deze stap niet aan de agent. Voer de SSO-inlog eenmalig handmatig uit in een zichtbare browser die door Playwright wordt bestuurd, en sla vervolgens de sessiestatus op: daaropvolgende uitvoeringen starten vanuit deze status.

def manual_sso_login(login_url: str, filepath="session.json"):
    """Een mens logt in in een zichtbare browser; de sessie wordt opgeslagen."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=False)
    context = browser.new_context()
    page = context.new_page()
    page.goto(login_url)
    input("Log in in het geopende venster en druk vervolgens op Enter...")
    save_session(context, filepath)
    browser.close()
    pw.stop()

Wanneer de sessie uiteindelijk verloopt, moet de workflow stoppen en opnieuw om deze menselijke inlog vragen. Voeg deze instructie toe aan de richtlijnen van de agent: als deze zich voor een pagina van een identiteitsprovider bevindt, stopt deze en meldt dit in plaats van iets te proberen.

Inlogstatus detecteren

Al deze mechaniek rust op een vraag die u betrouwbaar moet kunnen beantwoorden: zijn we ingelogd? Een toegewijde functie kruist twee signalen: eerst de huidige URL, aangezien een omleiding naar /login ondubbelzinnig is, en vervolgens de aanwezigheid van een element gereserveerd voor geauthenticeerde gebruikers, doorgaans het accountmenu. De eerste test is direct, de tweede dekt applicaties die de inlogpagina tonen zonder de URL te wijzigen.

from playwright.sync_api import TimeoutError as PlaywrightTimeoutError

def is_logged_in(page) -> bool:
    """Controleert of de sessie actief is."""
    # URL-controle
    if "/login" in page.url or "/signin" in page.url:
        return False

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

De except richt zich precies op het verstrijken van de time-out: een kale except: zou ook een keyboard-interrupt of een echte programmeerfout opslokken, en die wilt u juist naar boven laten borrelen.

Beveiliging van inloggegevens

"Sla nooit wachtwoorden op in uw broncode, uw prompts of uw logs."

— Fundamentele beveiligingsregel

In de praktijk vertaalt deze regel zich in een paar gewoonten die bijna niets kosten zodra ze zijn ingevoerd. Inloggegevens leven in omgevingsvariabelen, tijdens ontwikkeling gevoed door een .env-bestand dat u direct uitsluit van versiebeheer via .gitignore—deze omissie is een klassieke oorzaak van lekken van geheimen in openbare repositories. Vervang dit bestand in productie door een secrets manager, zoals Vault of AWS Secrets Manager, die waarden op afroep levert en toegang traceert. Alleen uw code leest ze, nooit het model. Voorzie regelmatige rotatie van wachtwoorden en API-tokens, zodat een oud lek niets meer opent. Filter tot slot uw logs om nooit gevoelige gegevens daar vast te leggen: een agent die trouw elke toetsaanslag logt, kopieert ook wat hem is opgedragen in te typen.

Belangrijkste punten

  • Het model ziet nooit een geheim: uw code voert wachtwoord en 2FA-code in met Playwright
  • Sla sessiestatus op met storage_state en behandel dat bestand als een geheim
  • TOTP wordt geautomatiseerd aan de kant van de code, gereserveerd voor een serviceaccount met beperkte rechten
  • Voer SSO-inlog eenmalig handmatig uit en hergebruik daarna de opgeslagen sessie
  • Controleer altijd de inlogstatus voordat u een workflow start