Uso del browser con il toolset dell'SDK

Gli SDK Python e TypeScript includono una classe per il "browser use tool" (strumento di uso del browser). Crei una sottoclasse e scrivi un metodo per ogni strumento membro, come navigate o left_click, basato sulla tua automazione del browser. L'SDK instrada ogni chiamata, controlla URL e percorsi dei file, interroga la tua callback di approvazione e costruisce ogni tool_result.

L'SDK non include un browser, un driver pronto all'uso né una "denylist" (lista di blocco). Driver di esempio per Playwright e per il Chrome DevTools Protocol, in Python e TypeScript, si trovano nella cartella browser-toolset del repository claude-quickstarts.

Avvio rapido

Un driver è la tua sottoclasse di BetaAbstractBrowserToolset20260801. Questo implementa navigate, screenshot e left_click, oltre a _browser_state (browserState in TypeScript), il report di stato di cui ogni driver ha bisogno. Nell'esempio, backend rappresenta il tuo wrapper attorno a una libreria di automazione del browser, come Playwright.

from anthropic import Anthropic
from anthropic.tools.browser import (
    BetaAbstractBrowserToolset20260801,
    BetaBrowserNavigateResult,
    BetaBrowserScreenshotResult,
    BrowserState,
    ToolsetCallContext,
)
from anthropic.types.beta import (
    BetaBrowserLeftClickInput,
    BetaBrowserNavigateInput,
    BetaBrowserScreenshotInput,
    BetaBrowserStateTabEntryParam,
)


class MyBrowser(BetaAbstractBrowserToolset20260801):
    def __init__(self, backend, **options):
        super().__init__(**options)
        self.backend = backend

    def _browser_state(self, context: ToolsetCallContext) -> BrowserState:
        return BrowserState(
            tabs=[
                BetaBrowserStateTabEntryParam(
                    tab_id=tab.id,
                    title=tab.title,
                    url=tab.url,
                    active=tab.id == self.backend.active,
                )
                for tab in self.backend.tabs()
            ],
            state_changes=self.backend.drain_changes(),
        )

    def navigate(
        self, context: ToolsetCallContext, input: BetaBrowserNavigateInput
    ) -> BetaBrowserNavigateResult:
        # input.url è un URL che ha superato la policy sugli URL, oppure "back", "forward",
        # o "reload". L'SDK aggiunge https:// quando Claude omette lo schema.
        page = self.backend.goto(input.url, input.tab_id)
        return BetaBrowserNavigateResult(
            url=page.url, status=page.status, title=page.title
        )

    def screenshot(
        self, context: ToolsetCallContext, input: BetaBrowserScreenshotInput
    ) -> BetaBrowserScreenshotResult:
        data = self.backend.png_base64(input.tab_id)
        return BetaBrowserScreenshotResult(data=data, media_type="image/png")

    def left_click(
        self, context: ToolsetCallContext, input: BetaBrowserLeftClickInput
    ) -> None:
        # Nulla da restituire: Claude legge "Clicked."
        self.backend.click(input.target, input.tab_id)

    def close(self) -> None:
        super().close()  # first, so no call is still using the browser when it closes
        if not self.backend.closed:
            self.backend.close()


client = Anthropic()
with MyBrowser(backend, allowed_domains=["example.com", "iana.org"]) as browser:
    runner = client.beta.messages.tool_runner(
        model="claude-opus-5-5",
        max_tokens=1024,
        tools=[browser],
        messages=[
            {
                "role": "user",
                "content": "Open example.com and tell me the page heading.",
            }
        ],
    )
    for message in runner:
        print(message)

Passa l'istanza stessa del driver come voce di tools. Un membro che non implementi viene inviato all'API come disabilitato. Se Claude lo chiama comunque, l'SDK restituisce un errore e l'esecuzione continua. Sovrascrivere execute cambia quali membri vengono inviati come disabilitati (Aggiungi hook prima e dopo). Il runner non chiude mai il toolset, quindi un'istanza può servire più esecuzioni. Chiudilo quando hai finito.

Personalizza un driver

Abilita o disabilita i membri

configs accetta le impostazioni per membro descritte in Configurare il toolset. Elenca solo i membri che modifichi:

# Un MyBrowser che implementa anche read_console
browser = MyBrowser(
    backend, configs={"read_console": {"enabled": True}, "navigate": {"enabled": False}}
)

L'SDK rifiuta una chiamata a un membro disabilitato prima che il tuo codice venga eseguito. Abilitare un membro che la tua classe non implementa è un errore di configurazione, a meno che la classe non sovrascriva execute.

Aggiungi hook prima e dopo

Sovrascrivi execute e chiama l'execute della classe padre. Il codice prima di quella chiamata viene eseguito dopo il controllo dell'URL (Imposta una policy degli URL) e confirm (Sottoponi ad approvazione i membri con conseguenze), e può modificare l'input. L'SDK non controlla di nuovo l'input modificato. Il codice dopo la chiamata riceve il risultato e può modificarlo. Solleva ToolError (lancialo con throw in TypeScript) per rifiutare la chiamata.

Sovrascrivere execute cambia quali membri vengono offerti a Claude. L'SDK considera ogni membro come implementato, quindi a Claude viene offerto ogni membro attivo per impostazione predefinita. Il MyBrowser dell'avvio rapido serve tre membri, quindi il seguente TracedBrowser offre a Claude membri che non può servire. Disattiva quei membri con configs prima di usarlo.

import time


class TracedBrowser(MyBrowser):
    def execute(self, context, name, input):
        started = time.monotonic()
        result = super().execute(context, name, input)
        elapsed_ms = (time.monotonic() - started) * 1000
        call_id = context.tool_use.id if context.tool_use else "-"
        log.info("%s %s %.0fms", call_id, name, elapsed_ms)
        return redact(result) if name == "get_page_text" else result

Implementa un driver

Sovrascrivi i membri supportati dal tuo browser. Ogni membro riceve il contesto della chiamata e l'input del membro come oggetto tipizzato, come BetaBrowserNavigateInput. I tipi di input provengono da anthropic.types.beta (@anthropic-ai/sdk/resources/beta in TypeScript). Strumenti membro elenca i campi di ogni input.

In TypeScript, scrivi i membri come metodi, non come campi arrow function, perché l'SDK li trova sul prototipo. In TypeScript, scrivi il membro type come type_. In Python, è type.

Restituisci i risultati

Ciò che un membro restituisce determina ciò che Claude legge. Un risultato riuscito termina con un blocco browser_state costruito dal tuo report di stato. Un risultato di errore non contiene alcun blocco.

Riporta lo stato del browser

L'SDK chiama _browser_state (l'opzione browserState in TypeScript) dopo ogni chiamata, incluse le chiamate rifiutate e non riuscite. Restituisci ogni scheda aperta e ciò che è cambiato dall'ultimo report:

• Schede aperte ed eventi di download.
• Un NavigationRefused per ogni navigazione bloccata dal tuo hook delle richieste.
• Un DialogDismissed per ogni finestra di dialogo nativa chiusa dal tuo driver.

Inserisci tutti questi elementi in state_changes. In Python, NavigationRefused(url=...) e DialogDismissed(kind=..., message=...) provengono da anthropic.tools.browser. In TypeScript, sono { type: "navigation_refused", url } e { type: "dialog_dismissed", kind, message }.

Gli ultimi due non sono cambiamenti di stato dell'API. L'SDK li riporta a Claude come testo al di fuori del blocco browser_state: una riga per tutte le navigazioni rifiutate, che non nomina alcun URL, e una riga per ciascuna delle prime tre finestre di dialogo chiuse, seguita dal conteggio delle eventuali altre.

Quando è aperta almeno una scheda, esattamente una deve essere attiva. Ogni membro che accetta un tab_id deve agire sulla scheda che indica. L'SDK usa il report per determinare da quale pagina proviene un risultato. I limiti dell'API sul report sono elencati in Traccia le schede con browser_state.

Gestisci gli errori

Prima che Claude legga il testo di errore di un membro, la riga restituita da un'azione come left_click, l'errore di un download non riuscito o il messaggio di una finestra di dialogo chiusa, l'SDK sostituisce ogni URL rifiutato dalla policy con (blocked). Sostituisce ogni percorso locale che la policy dei file non espone con (path hidden). Il controllo può non rilevare alcuni URL e percorsi. Un ToolError proveniente dalla tua policy degli URL, dalla policy dei file o dal callable confirm raggiunge Claude così come è scritto, quindi escludi dal suo testo gli URL rifiutati e i percorsi locali. Cattura le eccezioni nei tuoi membri e solleva ToolError (lancialo con throw in TypeScript) con il tuo testo.

Esegui senza il tool runner

Passa l'istanza in tools (browser.toJSON() in TypeScript) e rispondi a ogni chiamata di membro con tool_result (toolResult in TypeScript). Lo strumento di uso del browser richiede di fermarsi alla prima chiamata non riuscita (Azioni batch). Dopo una chiamata non riuscita, questo ciclo risponde alle chiamate successive del turno senza eseguirle:

from anthropic.types.beta import BetaToolResultBlockParam

NOT_EXECUTED = "Not executed: an earlier action in this turn failed."
MAX_TURNS = 10

with MyBrowser(backend, allowed_domains=["example.com"]) as browser:
    messages = [{"role": "user", "content": "Open example.com"}]
    for _ in range(MAX_TURNS):
        response = client.beta.messages.create(
            model="claude-opus-5-5",
            max_tokens=1024,
            tools=[browser],
            messages=messages,
        )
        messages.append({"role": "assistant", "content": response.content})
        calls = [
            block
            for block in response.content
            if block.type == "tool_use" and block.toolset_name == browser.toolset_name
        ]
        if not calls:
            break
        results: list[BetaToolResultBlockParam] = []
        failed = False
        for call in calls:
            if failed:
                # Dopo una chiamata fallita, il resto del turno riceve una risposta ma non viene eseguito.
                results.append(
                    {
                        "type": "tool_result",
                        "tool_use_id": call.id,
                        "toolset_name": call.toolset_name,
                        "content": NOT_EXECUTED,
                        "is_error": True,
                    }
                )
                continue
            result = browser.tool_result(call)
            failed = bool(result.get("is_error"))
            results.append(result)
        messages.append({"role": "user", "content": results})

Ogni risposta a una chiamata saltata contiene is_error, il toolset_name della chiamata e il testo esatto richiesto da Azioni batch. Il tool runner invia la stessa risposta.

Esegui il toolset in sicurezza

La prossima azione di Claude dipende dalle pagine che legge. Una pagina, o un testo iniettato in essa, può tentare di raggiungere servizi interni o di estrarre file dall'host. Può anche tentare di attivare azioni con effetti reali. Prima di eseguire un driver su qualcosa che non sia un browser usa e getta, segui questi sei passaggi:

1. Imposta una policy degli URL: allowed_domains, blocked_domains o la tua url_policy.
2. Intercetta le richieste nel driver e chiedi al toolset un verdetto.
3. Applica una policy di uscita al container, in modo che la rete blocchi ciò che il driver non può vedere.
4. Limita upload e download, oppure lascia gli upload disattivati.
5. Sottoponi ad approvazione i membri con conseguenze con confirm.
6. Isola l'host del browser in un container o VM dedicato per ogni sessione.

L'SDK applica i passaggi 1, 4 e 5 secondo la tua configurazione. I passaggi 2, 3 e 6 spettano al tuo driver e al tuo deployment. Si applicano anche le precauzioni descritte in Considerazioni sulla sicurezza.

Imposta una policy degli URL

Imposta allowed_domains (allowedDomains in TypeScript) sui siti di cui l'attività ha bisogno. Una voce in ciascuno dei due elenchi è un dominio (che copre anche i suoi sottodomini), un indirizzo IP o una rete CIDR. Con allowed_domains impostato, il toolset rifiuta ogni altro host.

browser = MyBrowser(backend, allowed_domains=["example.com", "iana.org"])

Se l'attività ha bisogno del web aperto, imposta invece blocked_domains (blockedDomains). Gli elenchi confrontano i nomi host senza risolverli. Una voce 127.0.0.0/8 nella denylist non blocca localhost, quindi indica sia gli host sia le reti. Quando imposti entrambi gli elenchi, prevale blocked_domains.

Una denylist non può intercettare un nome pubblico che si risolve in un indirizzo privato. Quindi, con blocked_domains, è la policy di uscita del container a impedire a un nome del genere di raggiungere un indirizzo privato.

# Elenca gli host e le reti che il browser può raggiungere ma Claude non deve:
# gli intervalli loopback, link-local e privati in IPv4 e IPv6, 0.0.0.0/8, gli
# indirizzi e i nomi dei metadati del tuo cloud (come metadata.google.internal),
# localhost e i tuoi hostname interni.
browser = MyBrowser(backend, blocked_domains=internal_networks)

Una url_policy (urlPolicy) sostituisce entrambi gli elenchi, e passarla insieme a uno dei due elenchi è un errore di configurazione. La tua policy non restituisce nulla per consentire un URL e solleva (lancia) ToolError per rifiutarlo. Per mantenere le regole predefinite, costruisci la policy predefinita con default_url_policy (defaultURLPolicy) e chiamala per prima dalla tua:

from urllib.parse import urlsplit

from anthropic.tools.browser import ToolError, URLContext, default_url_policy

listed = default_url_policy(allowed_domains=["example.com"])


def url_policy(context: URLContext, url: str) -> None:
    listed(context, url)  # the default rules first
    if context.phase == "request" and urlsplit(url).scheme != "https":
        raise ToolError("Only https navigation is allowed.")


browser = MyBrowser(backend, url_policy=url_policy)

La policy viene eseguita su ogni URL di navigate prima del tuo codice, sull'URL riportato da un risultato e su ogni URL di scheda e di download in un report di stato. Nei risultati e nei report di stato, salta gli indirizzi che non indicano alcun host remoto: una scheda vuota, about:blank, la pagina chrome-error: del browser e i documenti data:.

Con qualsiasi policy, il toolset rifiuta un navigate verso uno schema diverso da http o https, eccetto about:blank. url_policy="allow_all" (urlPolicy: "allow_all") disattiva la policy, ma non questa regola sugli schemi.

Passare url_policy=None (urlPolicy: null) fa sì che il costruttore sollevi un errore di configurazione, quindi un None (null) letto dalla tua configurazione non può disattivare i controlli. In TypeScript, undefined lascia l'opzione non impostata, come se non la passassi.

Quando una pagina arriva su un indirizzo rifiutato, Claude legge che il suo contenuto è stato trattenuto e la scheda viene elencata come (blocked). Finché la scheda non si trova di nuovo su un indirizzo consentito, il toolset rifiuta le chiamate su di essa. Le eccezioni sono navigate (ma non "reload"), new_tab, list_tabs, switch_tab e close_tab.

Intercetta le richieste nel driver

La policy degli URL valuta solo gli indirizzi che il toolset vede: navigazioni, risultati e report di stato. Non vede le sotto-risorse, le chiamate fetch(), i WebSocket né dove si risolve un nome host.

Il toolset rileva un nuovo indirizzo solo al termine di una chiamata, nel risultato o nel report di stato della chiamata. Quindi una chiamata può ancora agire su una pagina rifiutata prima di allora, e l'SDK può al massimo trattenere il risultato di quella chiamata. A meno che il tuo driver non valuti ogni richiesta, inclusi i passaggi di reindirizzamento, una pagina che reindirizza a un indirizzo rifiutato viene comunque caricata.

Nel "request hook" (hook delle richieste) del tuo driver (la funzione che la tua libreria di automazione chiama prima di ogni richiesta), chiama check_url (checkURL). Applica la policy stessa del toolset, così non scrivi le regole due volte:

from anthropic.tools.browser import URLContext


class MyBrowser(BetaAbstractBrowserToolset20260801):
    ...

    # Registrato su un contesto browser Playwright con context.route("**/*", self._guard)
    def _guard(self, route):
        url_context = URLContext(
            member="navigate", phase="request", tab_id=self.backend.active
        )
        if not self.check_url(url_context, route.request.url).allowed:
            return route.abort("blockedbyclient")
        route.continue_()

check_url applica la stessa regola sugli schemi e la stessa policy di navigate. Un hook delle richieste come questo non vede gli handshake WebSocket, le richieste dei service worker né i passaggi di reindirizzamento. Blocca i service worker. Valuta gli handshake WebSocket e i passaggi di reindirizzamento con un hook che li veda.

Nella fase di richiesta, check_url consente solo URL http, https e about:blank. Quindi, per un WebSocket, cambia ws:// in http:// e wss:// in https:// prima di chiamarlo.

Applica una policy di uscita al container

L'intercettazione non può vedere ogni richiesta effettuata dal browser, e la policy degli URL non vede dove si risolve un nome. Una "egress policy" (policy di uscita) applicata dalla rete del container copre entrambi i casi:

• Blocca gli intervalli di indirizzi loopback, link-local e privati in IPv4 e IPv6, e 0.0.0.0/8. Ciò include l'indirizzo dei metadati cloud 169.254.169.254.
• Consenti connessioni in uscita solo verso gli host di cui l'attività ha bisogno. Se le tue regole corrispondono a indirizzi IP, risolvi i nomi host che consenti all'avvio del container.
• Consenti il DNS solo verso il resolver del container.
• Se il tuo driver raggiunge il browser tramite una porta DevTools locale, consenti il loopback solo su quella porta. Una regola per tutto il loopback aprirebbe alla pagina ogni servizio locale.

Limita upload e download

file_upload è disattivato per impostazione predefinita. Senza una file_policy, l'SDK rifiuta ogni upload che indica un percorso o un ID documento. Per abilitare gli upload, passa una LocalFilePolicy (NodeFilePolicy in TypeScript) con una directory di upload che contenga solo i file dell'attività:

from anthropic.tools.browser import LocalFilePolicy

# Un MyBrowser che implementa anche file_upload
browser = MyBrowser(
    backend,
    configs={"file_upload": {"enabled": True}},
    confirm=make_confirm(),  # required for file_upload; see Gate consequential members
    file_policy=LocalFilePolicy(
        upload_roots=["/task/uploads"],
        download_dir="/task/downloads",
        expose_download_paths=False,
    ),
)

L'SDK risolve ogni percorso di upload, seguendo i link simbolici, e rifiuta qualsiasi percorso al di fuori delle radici di upload. La policy dei file rifiuta una directory di download all'interno di una radice di upload. Il percorso di un download raggiunge Claude solo quando expose_download_paths (exposeDownloadPaths) è true e il file si trova all'interno della directory di download.

I controlli sui percorsi forniti con l'SDK risolvono i percorsi sul filesystem del processo che esegue l'SDK. Proteggono solo un browser che condivide quel filesystem. Per un browser remoto, segui invece Browser remoti e ospitati.

Configura i download in questo modo:

• Crea tu stesso la directory di download con modalità 0700 e montala con noexec,nosuid,nodev.
• Tieni la directory fuori dalla portata di altri strumenti che Claude può chiamare, come una shell o uno strumento per i file.
• In un cambiamento di stato download_failed, scrivi error come frase fissa. Il testo di un'eccezione può contenere il percorso o l'URL.
• Non leggere un file scaricato nella conversazione, né eseguirlo, finché una persona non decide di farlo.

Sottoponi ad approvazione i membri con conseguenze

javascript_exec e file_upload sono disattivati per impostazione predefinita. Se abiliti uno dei due senza un callable confirm, il costruttore solleva un errore di configurazione. Con un callable confirm, l'SDK lo chiama prima di ogni chiamata che sta per essere eseguita. Senza di esso, non viene chiesto nulla.

Restituisci True per eseguire la chiamata o False per rifiutarla (true e false in TypeScript). Quando il tuo callable interpella una persona, mostrale il membro, l'URL della pagina e l'input della chiamata. Prima, esegui l'escape di ogni carattere dell'input che non rientra nell'ASCII stampabile, perché l'input può contenere testo proveniente dalla pagina.

Questo esempio chiede conferma per i due membri soggetti ad approvazione tramite la tua funzione ask_user (askUser in TypeScript) e approva il resto:

import json
from collections.abc import Callable

from anthropic.tools.browser import ConfirmContext

GATED = {"javascript_exec", "file_upload"}


def shown(context: ConfirmContext) -> str:
    """The call's input as JSON, with every character outside printable
    ASCII escaped."""
    return json.dumps(context.input.to_dict(), ensure_ascii=True, indent=2)


def make_confirm() -> Callable[[ConfirmContext], bool]:
    granted: set[tuple[str, str, str]] = set()

    def confirm(context: ConfirmContext) -> bool:
        name = context.member
        if name not in GATED:
            return True
        detail = shown(context)
        page = context.tab_url
        origin = context.origin
        if page is None or origin is None or origin.startswith("chrome-error:"):
            # Nessuna origine o una pagina di errore: chiedi ogni volta.
            return ask_user(
                f"Allow {name} on {page or 'a page with no origin'}?\n{detail}"
            )
        # Un'approvazione copre solo questo input esatto su questa pagina.
        key = (name, page, detail)
        if key not in granted and ask_user(f"Allow {name} on {page}?\n{detail}"):
            granted.add(key)
        return key in granted

    return confirm


# Un MyBrowser che implementa anche javascript_exec e file_upload
browser = MyBrowser(
    backend,
    configs={"javascript_exec": {"enabled": True}, "file_upload": {"enabled": True}},
    confirm=make_confirm(),
)

Ogni chiamata a make_confirm() (makeConfirm() in TypeScript) restituisce un callable senza approvazioni. Chiamala una volta per ogni toolset e assegna a ogni utente il proprio toolset.

Un'approvazione copre la pagina così come l'ha mostrata l'ultimo report di stato, e la pagina può cambiare prima che la chiamata venga eseguita. Acquisti, messaggi inviati e termini accettati avvengono tramite membri ordinari come left_click e type, quindi confirm non può individuarli per nome. Per farli approvare da una persona, chiedi conferma anche per quei membri.

Non abilitare javascript_exec su un driver che non intercetta le richieste. Uno script eseguito su una pagina rifiutata può copiarne il contenuto in un punto da cui una lettura successiva lo restituisce.

Isola l'host del browser

Esegui il browser in un container o VM dedicato e con privilegi minimi per ogni sessione:

• Esegui come utente non root, con un filesystem root di sola lettura dove il browser lo consente.
• Non montare nulla dall'host oltre alle directory di upload e download che hai configurato, se presenti.
• Tieni le credenziali fuori dall'ambiente e parti da un profilo del browser nuovo.
• Non condividere alcun filesystem con altri strumenti che Claude può chiamare.

Esegui il codice che chiama l'API al di fuori del container del browser, perché quel codice contiene la tua chiave API e la conversazione. Il tool runner e tool_result eseguono entrambi il toolset nel processo di quel codice, quindi il browser non condivide il filesystem del toolset. Tratta il browser come remoto: si applica Browser remoti e ospitati.

Tratta tutto ciò che una pagina restituisce come non attendibile, inclusi il testo della pagina, gli screenshot, le voci della console e della rete, i titoli delle schede e i nomi dei download.

Browser remoti e ospitati

Alcuni browser non condividono un filesystem con il processo che esegue l'SDK. Ne sono esempi un browser in un altro container, uno che raggiungi tramite un URL DevTools e uno fornito da un servizio di browser ospitato. Con questi, la policy degli URL, l'intercettazione delle richieste e confirm vengono comunque eseguiti nel tuo processo.

Con un browser ospitato, il provider controlla il traffico in uscita e l'isolamento dell'host. La tua policy di uscita non si applica lì, quindi l'hook delle richieste del driver è il tuo unico controllo sulle richieste del browser. Verifica cosa può raggiungere la rete del browser.

I controlli sui percorsi forniti con l'SDK non proteggono un browser remoto. LocalFilePolicy (NodeFilePolicy in TypeScript) controlla i percorsi sul filesystem del processo che esegue l'SDK, mentre il browser legge e scrive sul proprio filesystem.

L'SDK non può rilevare che un browser è remoto. Quindi, per un browser remoto, mantieni file_upload disattivato a meno che il tuo driver non controlli i percorsi di upload dove viene eseguito il browser, con una propria FilePolicy. Una FilePolicy verifica i percorsi e gli ID documento di ogni upload e decide se Claude vede il percorso di un download.

Fai in modo che un browser remoto rifiuti i download, a meno che il suo host non abbia la configurazione dei download descritta in Limita upload e download.

I driver di esempio seguono questa regola. Su un browser remoto, sollevano un errore di configurazione per una file_policy (filePolicy) o per un file_upload abilitato, e impostano il browser in modo che rifiuti i download.

Tieni la chiave API del provider e l'URL di connessione della sessione, che può contenere una chiave, fuori da log, risultati degli strumenti e testi di errore. Se il provider registra le sessioni, la registrazione è un'ulteriore copia di tutto ciò che Claude ha visto e digitato, e a essa si applicano i termini di conservazione del provider.

Riferimento

Le opzioni del costruttore hanno lo stesso significato in entrambi gli SDK:

Non puoi modificare un'opzione dopo la costruzione. I valori predefiniti, gli errori, i campi del contesto e la classe Python asincrona (BetaAsyncAbstractBrowserToolset20260801) sono documentati nell'SDK Python e nell'SDK TypeScript.

Limitazioni

• La policy degli URL controlla le navigazioni, non ogni richiesta: Consulta Intercetta le richieste nel driver.
• Un'approvazione si basa sull'ultimo report di stato: La pagina può cambiare dopo quel report. L'SDK non controlla di nuovo la pagina prima che la chiamata venga eseguita.
• Le chiamate su un toolset vengono eseguite una alla volta: Non puoi disattivare questo comportamento.
• L'SDK non controlla che gli ID delle schede siano univoci, che una scheda sia attiva o quante schede ci siano: L'API rifiuta un report che viola queste regole.

Passaggi successivi