---
title: Browser-Use-Tool
url: https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool
description: Lass Claude mit dem Browser-Use-Tool in deiner eigenen Browser-Umgebung Webseiten aufrufen, lesen und mit ihnen interagieren.
featureMetadata:
status: ga
zdr:
eligibility: eligible
note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).
supportedModels:
- claude-fable-5-1
- claude-mythos-5-1
- claude-fable-5
- claude-mythos-5
- claude-opus-5-5
- claude-opus-5
- claude-sonnet-5-5
- claude-sonnet-5
- claude-opus-4-8
- claude-haiku-5-5
supportedPlatforms:
Claude API: ga
Google Cloud: ga
---
**Beginne mit den SDK-Toolsets:** Die Python- und TypeScript-SDKs enthalten eine Browser-Toolset-Klasse, die sich in der Beta befindet. Beginne mit [einer Partner-Integration](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-sdk#partner-integrations) oder sieh dir [Browser- und Computernutzung mit den SDK-Toolsets](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-sdk) an. Verwende diese Seite als Tool-Referenz oder wenn du die Tool-Aufrufe selbst verarbeitest.
Mit dem Browser-Use-Tool kann Claude in einem Browser, den deine Anwendung ausführt, Webseiten navigieren, lesen und mit ihnen interagieren. Claude arbeitet mit der Seite sowohl über ihre Struktur (den „accessibility tree“ (Barrierefreiheitsbaum), Elemente, Formulare und Tabs) als auch über Screenshots und Viewport-Koordinaten.
Das Tool ist ein von Anthropic definiertes [Client-Toolset](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference#client-toolsets): Ein einzelner `browser_toolset_20260801`-Eintrag in `tools` gibt Claude standardmäßig 27 „member tools“ (Member-Tools), etwa `navigate`, `read_page`, `left_click` und `screenshot`, plus vier weitere, wenn du [sie aktivierst](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#enable-optional-member-tools). Deine Anwendung führt jeden Aufruf mit ihrer eigenen Browser-Automatisierung aus; auf Anthropics Seite läuft nichts. Das Tool ist derzeit nicht in [Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/tools) verfügbar.
Wähle Browser Use, wenn die Aufgabe innerhalb von Webseiten bleibt und darin besteht, auf ihnen zu handeln, oder wenn Seiten ihre Inhalte mit JavaScript aufbauen. Wenn eine Aufgabe einen ganzen Desktop benötigt, verwende das [Computer-Use-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool), das ausschließlich über Screenshots und Koordinaten arbeitet. Zum Lesen von Seiten, auf die du Claude verweisen kannst, oder zum Finden von Quellen im Web sind das [Web-Fetch-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool) und das [Web-Search-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool) leichtgewichtiger. Sie sind [Server-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools), die die API für dich ausführt, ohne dass ein Browser bedient werden muss.
Mit Browser Use liest Claude Live-Webseiten und handelt auf ihnen, daher ist alles, was eine Seite liefert, nicht vertrauenswürdige Eingabe, und die Aktionen, die Claude ausführt, können reale Auswirkungen haben. Siehe [Sicherheitsüberlegungen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#security-considerations), bevor du bereitstellst.
## Schnellstart
Das Browser-Use-Tool ist in der Claude API und auf [Google Cloud](https://platform.claude.com/docs/de/build-with-claude/claude-on-vertex-ai) verfügbar: Füge dem `tools`-Array einer [Messages API](https://platform.claude.com/docs/de/api/messages/create)-Anfrage einen Eintrag vom Typ `browser_toolset_20260801` ohne `name` hinzu.
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 2048,
"tools": [
{
"type": "browser_toolset_20260801"
}
],
"messages": [
{
"role": "user",
"content": "Open example.com/docs and tell me how to get started."
}
]
}'
```
```bash CLI
ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 2048
tools:
- type: browser_toolset_20260801
messages:
- role: user
content: Open example.com/docs and tell me how to get started.
YAML
```
```python Python
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-opus-5-5",
max_tokens=2048,
tools=[{"type": "browser_toolset_20260801"}],
messages=[
{
"role": "user",
"content": "Open example.com/docs and tell me how to get started.",
}
],
)
print(response)
```
```typescript TypeScript
const client = new Anthropic();
const response = await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 2048,
tools: [{ type: "browser_toolset_20260801" }],
messages: [
{
role: "user",
content: "Open example.com/docs and tell me how to get started."
}
]
});
console.log(response);
```
```csharp C#
var client = new AnthropicClient();
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 2048,
Tools = [new BrowserToolset20260801()],
Messages =
[
new MessageParam
{
Role = Role.User,
Content = "Open example.com/docs and tell me how to get started.",
},
],
};
var response = await client.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 2048,
Tools: []anthropic.ToolUnionParam{
{OfBrowserToolset20260801: &anthropic.BrowserToolset20260801Param{}},
},
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Open example.com/docs and tell me how to get started.")),
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response.RawJSON())
```
```java Java
import com.anthropic.models.messages.BrowserToolset20260801;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(2048L)
.addTool(BrowserToolset20260801.builder().build())
.addUserMessage("Open example.com/docs and tell me how to get started.")
.build();
Message response = client.messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->messages->create(
maxTokens: 2048,
messages: [
['role' => 'user', 'content' => 'Open example.com/docs and tell me how to get started.'],
],
model: 'claude-opus-5-5',
tools: [
['type' => 'browser_toolset_20260801'],
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.messages.create(
model: "claude-opus-5-5",
max_tokens: 2048,
tools: [
{ type: "browser_toolset_20260801" }
],
messages: [
{
role: "user",
content: "Open example.com/docs and tell me how to get started."
}
]
)
puts response
```
Claudes erste Antwort endet mit `stop_reason: "tool_use"` und enthält einen oder mehrere Member-`tool_use`-Blöcke, von denen jeder in `name` ein Member-Tool benennt und `"toolset_name": "browser"` trägt:
```json Output
{
"id": "msg_01HCDu4XSTLzTAcodEQ58vDo",
"type": "message",
"role": "assistant",
"model": "claude-opus-5-5",
"content": [
{
"type": "text",
"text": "I'll open the documentation and read the page to find the getting-started instructions."
},
{
"type": "tool_use",
"id": "toolu_01NRLabsLyVHZPKxbKvkfSMn",
"name": "navigate",
"toolset_name": "browser",
"input": { "url": "https://example.com/docs" }
},
{
"type": "tool_use",
"id": "toolu_01UvHU5cDyTZ2vXKf5wCkPqR",
"name": "read_page",
"toolset_name": "browser",
"input": { "filter": "interactive" }
}
],
"stop_reason": "tool_use",
"stop_sequence": null
}
```
Dein „executor" (Ausführungskomponente), also der Teil deiner Anwendung, der den Browser steuert und Tool-Ergebnisse erzeugt, führt `navigate` und dann `read_page` aus. Deine Anwendung gibt in ihrer nächsten Anfrage pro Block ein `tool_result` zurück und wiederholt dabei jeweils `toolset_name`. Das `navigate`-Ergebnis meldet den Tab, in dem die Seite geladen wurde, in einem `browser_state`-Block; das `read_page`-Ergebnis ist Text, in dem jedes Element eine Referenz trägt:
```json
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_01NRLabsLyVHZPKxbKvkfSMn",
"toolset_name": "browser",
"content": [
{ "type": "text", "text": "Navigated to https://example.com/docs" },
{
"type": "browser_state",
"tabs": [
{
"tab_id": "tab-1",
"title": "Documentation",
"url": "https://example.com/docs",
"active": true
}
]
}
]
},
{
"type": "tool_result",
"tool_use_id": "toolu_01UvHU5cDyTZ2vXKf5wCkPqR",
"toolset_name": "browser",
"content": [
{
"type": "text",
"text": "link \"Documentation\" [ref_1]\nlink \"Getting started\" [ref_2]\ntextbox \"Search docs\" [ref_3]\nbutton \"Search\" [ref_4]\nlink \"Pricing\" [ref_5]"
}
]
}
]
}
```
Claude verfügt nun über Referenzen, auf die es einwirken kann, sodass es in seinem nächsten Zug `ref_2` anklicken kann, um die Einstiegsseite zu öffnen, ohne den Link zuerst in einem Screenshot suchen zu müssen.
## So funktioniert Browser Use
Browser Use läuft als „agent loop“ (Agentenschleife) in deiner Anwendung: Claude gibt Member-Tool-Aufrufe zurück, dein Executor führt sie im Browser aus, und du gibst die Ergebnisse zurück, bis Claude mit Text antwortet.
* Füge deiner API-Anfrage den `browser_toolset_20260801`-Eintrag und optional weitere Tools hinzu.
* Füge einen Benutzer-Prompt hinzu, der die Arbeit mit Webseiten erfordert, zum Beispiel: „Öffne example.com/docs und sag mir, wie ich anfange."
* Claude gibt in einem einzigen Assistant-Zug einen oder mehrere `tool_use`-Blöcke zurück; mehrere in einem Zug bilden eine Batch-Aktion, zum Beispiel `left_click`, dann `type`, dann `key`.
* Der `name` jedes Blocks ist der Member-Name, jeder trägt `"toolset_name": "browser"`, und `input` enthält nur die Parameter dieses Members, ohne `action`-Feld. Der `stop_reason` der Antwort ist `tool_use`.
* Iteriere über jeden `tool_use`-Block in `response.content` (geh nicht davon aus, dass es genau einer ist) und führe sie nacheinander in der Reihenfolge ihres Auftretens aus, da spätere Aufrufe in der Regel von früheren abhängen.
* Gib in einer neuen `user`-Nachricht pro Block ein `tool_result` zurück, zugeordnet über `tool_use_id` und jeweils mit `"toolset_name": "browser"`. Jeder Aufruf muss beantwortet werden, sonst wird die nächste Anfrage abgelehnt.
* Wenn ein Aufruf fehlschlägt, gib für diesen Block `is_error: true` mit einer Textbeschreibung zurück und wende dann die Abbruchregel aus [Batch-Aktionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#batch-actions) auf jeden späteren Block im Zug an.
* Claude liest die Ergebnisse (Seitentext, Barrierefreiheitsbäume, Screenshots, Tab-Zustand) und gibt, falls es mehr braucht, weitere Member-Aufrufe zurück, womit du wieder bei Schritt 3 bist.
* Andernfalls gibt es eine Textantwort an den Benutzer zurück.
Hier ist ein Gerüst des Tool-Aufruf-Schritts dieses Loops in zwei Teilen. Zuerst stehen Stub-Member-Handler für deine Browserautomatisierung. Fünf Members (`navigate`, `read_page`, `left_click`, `type` und `screenshot`) geben den Text zurück, oder bei `screenshot` den Bildblock, der zum Ergebnisinhalt wird, und der Dispatcher löst einen Fehler für jeden Member aus, den er nicht implementiert.
```python Python
# Platzhalter-Bilddaten; ein echter Executor erfasst den Viewport und gibt die PNG-Bytes zurück
PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
def navigate(url):
return f"navigated to {url}"
def read_page():
return 'link "Docs" [ref_1]\nbutton "Search" [ref_2]'
def click(target):
# Ein Ziel ist eine Elementreferenz aus read_page oder find oder eine Viewport-Koordinate
if target["type"] == "ref":
return f"clicked {target['ref']}"
return f"clicked at ({target['x']}, {target['y']})"
def type_text(text):
return f"typed: {text}"
def capture_screenshot() -> list[ImageBlockParam]:
# screenshot antwortet mit einem Bildblock statt Text: gib die Ergebnis-Inhaltsliste zurück
return [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": PLACEHOLDER_PNG,
},
}
]
def handle_browser_action(name, tool_input):
if name == "navigate":
return navigate(tool_input["url"])
elif name == "read_page":
return read_page()
elif name == "left_click":
return click(tool_input["target"])
elif name == "type":
return type_text(tool_input["text"])
elif name == "screenshot":
return capture_screenshot()
# Behandle weitere Aktionen nach Bedarf
raise ValueError(f"Unknown or unimplemented member: {name}")
```
```typescript TypeScript
// Platzhalter-Bilddaten; ein echter Executor erfasst den Viewport als PNG-Bytes
const PLACEHOLDER_PNG =
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
function navigate(url: string): string {
return `navigated to ${url}`;
}
function readPage(): string {
return 'link "Docs" [ref_1]\nbutton "Search" [ref_2]';
}
function clickElement(ref: string): string {
return `clicked ${ref}`;
}
function clickAt(x: number, y: number): string {
return `clicked at (${x}, ${y})`;
}
function typeText(text: string): string {
return `typed: ${text}`;
}
function captureScreenshot(): Anthropic.ImageBlockParam[] {
// screenshot antwortet mit einem Bildblock statt mit Text
return [
{
type: "image",
source: {
type: "base64",
media_type: "image/png",
data: PLACEHOLDER_PNG
}
}
];
}
function handleBrowserAction(
action: string,
input: unknown
): string | Anthropic.ImageBlockParam[] {
const params: object = typeof input === "object" && input !== null ? input : {};
if (action === "navigate" && "url" in params) {
return navigate(String(params.url));
} else if (action === "read_page") {
return readPage();
} else if (action === "left_click" && "target" in params) {
// target ist eine Elementreferenz aus read_page oder eine Viewport-Koordinate
const target: object =
typeof params.target === "object" && params.target !== null ? params.target : {};
if ("type" in target && target.type === "ref" && "ref" in target) {
return clickElement(String(target.ref));
} else if ("x" in target && "y" in target) {
return clickAt(Number(target.x), Number(target.y));
}
} else if (action === "type" && "text" in params) {
return typeText(String(params.text));
} else if (action === "screenshot") {
return captureScreenshot();
}
// Behandle weitere Aktionen nach Bedarf
throw new Error(`Unknown or unimplemented member: ${action}`);
}
```
```csharp C#
// Platzhalter-Bilddaten; ein echter Executor erfasst den Viewport und gibt die PNG-Bytes zurück
const string PlaceholderPng = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
string Navigate(string url) => $"navigated to {url}";
string ReadPage() =>
"""
link "Docs" [ref_1]
button "Search" [ref_2]
""";
string ClickRef(string elementRef) => $"clicked {elementRef}";
string ClickAt(int x, int y) => $"clicked at ({x}, {y})";
// target ist {"type": "ref", "ref": "ref_1"} oder {"type": "coordinate", "x": 640, "y": 380}
string Click(JsonElement target) =>
target.GetProperty("type").GetString() == "ref"
? ClickRef(target.GetProperty("ref").GetString()!)
: ClickAt(target.GetProperty("x").GetInt32(), target.GetProperty("y").GetInt32());
string TypeText(string text) => $"typed: {text}";
// screenshot antwortet mit einem Bildblock statt Text: gib die Ergebnis-Content-Liste zurück
List CaptureScreenshot() =>
[
new ImageBlockParam(
new Base64ImageSource { Data = PlaceholderPng, MediaType = MediaType.ImagePng }
),
];
ToolResultBlockParamContent HandleBrowserAction(
string action,
IReadOnlyDictionary input
) =>
action switch
{
"navigate" => Navigate(input["url"].GetString()!),
"read_page" => ReadPage(),
"left_click" => Click(input["target"]),
"type" => TypeText(input["text"].GetString()!),
"screenshot" => CaptureScreenshot(),
// Behandle weitere Aktionen nach Bedarf
_ => throw new NotSupportedException($"Unknown or unimplemented member: {action}"),
};
```
```go Go
// placeholderPNG steht für eine echte Aufnahme: Ein Executor gibt den
// Viewport als base64-kodierte PNG-Daten zurück.
const placeholderPNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
// textContent verpackt Text als tool_result-Inhalt.
func textContent(text string) []anthropic.ToolResultBlockParamContentUnion {
return []anthropic.ToolResultBlockParamContentUnion{
{OfText: &anthropic.TextBlockParam{Text: text}},
}
}
func navigate(url string) string {
return fmt.Sprintf("navigated to %s", url)
}
func readPage() string {
return "link \"Docs\" [ref_1]\nbutton \"Search\" [ref_2]"
}
func clickRef(ref string) string {
return fmt.Sprintf("clicked %s", ref)
}
func clickAt(x, y int) string {
return fmt.Sprintf("clicked at (%d, %d)", x, y)
}
func typeText(text string) string {
return fmt.Sprintf("typed: %s", text)
}
// captureScreenshot gibt einen Bildblock statt Text zurück.
func captureScreenshot() []anthropic.ToolResultBlockParamContentUnion {
return []anthropic.ToolResultBlockParamContentUnion{{
OfImage: &anthropic.ImageBlockParam{
Source: anthropic.ImageBlockParamSourceUnion{
OfBase64: &anthropic.Base64ImageSourceParam{
MediaType: anthropic.Base64ImageSourceMediaTypeImagePNG,
Data: placeholderPNG,
},
},
},
}}
}
func handleBrowserAction(action string, params map[string]any) ([]anthropic.ToolResultBlockParamContentUnion, error) {
switch action {
case "navigate":
if url, ok := params["url"].(string); ok {
return textContent(navigate(url)), nil
}
case "read_page":
return textContent(readPage()), nil
case "left_click":
// target ist entweder eine Elementreferenz aus read_page oder eine Viewport-Koordinate
target, _ := params["target"].(map[string]any)
if ref, ok := target["ref"].(string); ok && target["type"] == "ref" {
return textContent(clickRef(ref)), nil
}
x, xok := target["x"].(float64)
y, yok := target["y"].(float64)
if xok && yok {
return textContent(clickAt(int(x), int(y))), nil
}
case "type":
if text, ok := params["text"].(string); ok {
return textContent(typeText(text)), nil
}
case "screenshot":
return captureScreenshot(), nil
// Behandle weitere Aktionen nach Bedarf
default:
return nil, fmt.Errorf("unknown or unimplemented member: %s", action)
}
// Wird erreicht, wenn in der Eingabe eines Members ein Feld fehlt oder ein Feld den falschen Typ hat
return nil, fmt.Errorf("invalid input for %s", action)
}
```
```java Java
/** Placeholder pixels; a real executor captures the viewport and base64-encodes the PNG. */
static final String PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
ToolResultBlockParam.Content captureScreenshot() {
ImageBlockParam image = ImageBlockParam.builder()
.source(Base64ImageSource.builder()
.mediaType(Base64ImageSource.MediaType.IMAGE_PNG)
.data(PLACEHOLDER_PNG)
.build())
.build();
return ToolResultBlockParam.Content.ofBlocks(
List.of(ToolResultBlockParam.Content.Block.ofImage(image)));
}
String navigate(String url) {
return "navigated to " + url;
}
String readPage() {
return """
link "Docs" [ref_1]
button "Search" [ref_2]""";
}
String clickRef(String ref) {
return "clicked " + ref;
}
String clickAt(long x, long y) {
return "clicked at (" + x + ", " + y + ")";
}
String typeText(String text) {
return "typed: " + text;
}
/** Runs one browser toolset member; {@code action} is the tool_use block's name. */
ToolResultBlockParam.Content handleBrowserAction(String action, Map input) {
if (action.equals("screenshot")) {
return captureScreenshot(); // the one member here that answers with an image block
}
String output = switch (action) {
case "navigate" -> navigate(input.get("url").asStringOrThrow());
case "read_page" -> readPage();
case "left_click" -> {
// target ist {"type": "ref", "ref": "ref_1"} oder {"type": "coordinate", "x": 640, "y": 380}
Map target =
(Map) input.get("target").asObject().get();
if (target.get("type").asStringOrThrow().equals("ref")) {
yield clickRef(target.get("ref").asStringOrThrow());
}
long x = ((Number) target.get("x").asNumber().get()).longValue();
long y = ((Number) target.get("y").asNumber().get()).longValue();
yield clickAt(x, y);
}
case "type" -> typeText(input.get("text").asStringOrThrow());
// Behandle weitere Aktionen nach Bedarf
default -> throw new UnsupportedOperationException("Unknown or unimplemented member: " + action);
};
return ToolResultBlockParam.Content.ofString(output);
}
```
```php PHP
// Platzhalter für echte PNG-Bytes; ein echter Executor erfasst den Viewport
const PLACEHOLDER_PNG = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==';
function navigateTo(string $url): string
{
return "navigated to {$url}";
}
function readPage(): string
{
return <<<'TEXT'
link "Docs" [ref_1]
button "Search" [ref_2]
TEXT;
}
function clickTarget(array $target): string
{
// Ein Ziel ist eine Elementreferenz aus read_page oder find oder eine Viewport-Pixelkoordinate
if ($target['type'] === 'ref') {
return "clicked {$target['ref']}";
}
return "clicked at ({$target['x']}, {$target['y']})";
}
function typeText(string $text): string
{
return "typed: {$text}";
}
function captureScreenshot(): array
{
// screenshot antwortet mit einem Bildblock statt Text, gib daher die Ergebnis-Inhaltsliste zurück
$image = [
'type' => 'image',
'source' => ['type' => 'base64', 'media_type' => 'image/png', 'data' => PLACEHOLDER_PNG],
];
return [$image];
}
function handleBrowserAction(string $name, array $input): string|array
{
return match ($name) {
'navigate' => navigateTo($input['url']),
'read_page' => readPage(),
'left_click' => clickTarget($input['target']),
'type' => typeText($input['text']),
'screenshot' => captureScreenshot(),
// Behandle weitere Aktionen nach Bedarf
default => throw new \RuntimeException("Unknown or unimplemented member: {$name}"),
};
}
```
```ruby Ruby
# Platzhalter-Bilddaten; ein echter Executor erfasst den Viewport als PNG.
PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
def navigate(url)
"navigated to #{url}"
end
def read_page
<<~TREE
link "Docs" [ref_1]
button "Search" [ref_2]
TREE
end
def click(target)
return "clicked #{target[:ref]}" if target[:type] == "ref"
"clicked at (#{target[:x]}, #{target[:y]})"
end
def type_text(text)
"typed: #{text}"
end
def capture_screenshot
[
{
type: "image",
source: { type: "base64", media_type: "image/png", data: PLACEHOLDER_PNG }
}
]
end
def handle_browser_action(name, input)
case name
when "navigate"
navigate(input[:url])
when "read_page"
read_page
when "left_click"
# target ist eine Elementreferenz (aus read_page oder find) oder eine Koordinate
click(input[:target])
when "type"
type_text(input[:text])
when "screenshot"
capture_screenshot
# Weitere Aktionen nach Bedarf behandeln
else
raise ArgumentError, "Unknown or unimplemented member: #{name}"
end
end
```
Der zweite Teil führt einen Batch der Reihe nach aus, leitet jeden Block an diese Handler weiter, wiederholt `toolset_name` auf jedem Ergebnis und wendet die Halt-Regel aus [Batch-Aktionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#batch-actions) an, wobei ein Handler-Fehler in ein Fehlerergebnis umgewandelt wird. Der Sampling-Loop, der ihn aufruft, ist der unter [Den Agenten-Loop verstehen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#understanding-the-agentic-loop) gezeigte, mit dem Browser-Toolset in `tools`.
```python Python
NOT_EXECUTED = "Not executed: an earlier action in this turn failed."
def process_tool_calls(response: Message) -> list[ToolResultBlockParam]:
"""
Run the browser actions in Claude's response in order and answer each
one. After the first failure the rest are skipped, because Claude planned
them assuming the earlier actions succeeded.
"""
tool_results: list[ToolResultBlockParam] = []
failed = False
for block in response.content:
# Nur das Browser-Toolset ist deklariert; leite andere Tools hierher, falls du sie hinzufügst
if block.type != "tool_use" or block.toolset_name != "browser":
continue
result: ToolResultBlockParam = {
"type": "tool_result",
"tool_use_id": block.id,
"toolset_name": "browser",
}
if failed:
result["content"] = NOT_EXECUTED
result["is_error"] = True
else:
try:
# Ein String oder eine Liste von Inhaltsblöcken; ein echter Executor fügt außerdem einen
# browser_state-Block zu Navigations- und Tab-Verwaltungsergebnissen hinzu
result["content"] = handle_browser_action(block.name, block.input)
except Exception as err:
result["content"] = f"Error: {err}"
result["is_error"] = True
failed = True
tool_results.append(result)
return tool_results
```
```typescript TypeScript
const HALT_TEXT = "Not executed: an earlier action in this turn failed.";
function browserResult(
toolUseId: string,
content: string | Anthropic.ImageBlockParam[],
isError?: boolean
): Anthropic.ToolResultBlockParam {
return {
type: "tool_result",
tool_use_id: toolUseId,
toolset_name: "browser",
content,
is_error: isError
};
}
function processToolCalls(response: Anthropic.Message): Anthropic.ToolResultBlockParam[] {
const toolResults: Anthropic.ToolResultBlockParam[] = [];
let failed = false;
for (const block of response.content) {
if (block.type !== "tool_use") {
continue;
}
if (block.toolset_name !== "browser") {
// Dieses Beispiel deklariert nur das Browser-Toolset; leite andere Tools
// hierher weiter, falls du sie hinzufügst.
continue;
}
if (failed) {
// Ein Batch stoppt beim ersten Fehler; beantworte spätere Aktionen als nicht ausgeführt
toolResults.push(browserResult(block.id, HALT_TEXT, true));
continue;
}
try {
// Ein String oder eine Liste von Bildblöcken; ein echter Executor fügt außerdem einen
// browser_state-Block zu Navigations- und Tab-Verwaltungsergebnissen hinzu
const result = handleBrowserAction(block.name, block.input);
toolResults.push(browserResult(block.id, result));
} catch (error) {
failed = true;
const message = error instanceof Error ? error.message : String(error);
toolResults.push(browserResult(block.id, `Error: ${message}`, true));
}
}
return toolResults;
}
```
```csharp C#
const string HaltText = "Not executed: an earlier action in this turn failed.";
List ProcessToolCalls(Message response)
{
List toolResults = [];
var failed = false;
foreach (var block in response.Content)
{
if (!block.TryPickToolUse(out var toolUse))
{
continue;
}
if (toolUse.ToolsetName != "browser")
{
// Dieses Beispiel deklariert nur das Browser-Toolset; leite andere Tools
// hierher weiter, falls du sie hinzufügst.
continue;
}
if (failed)
{
// Ein Batch stoppt beim ersten Fehler; beantworte spätere Aktionen, ohne sie auszuführen
toolResults.Add(
new ToolResultBlockParam(toolUse.ID)
{
Content = HaltText,
IsError = true,
ToolsetName = "browser",
}
);
continue;
}
try
{
// Ein String oder eine Liste von Content-Blöcken; ein echter Executor fügt außerdem einen
// browser_state-Block zu Navigations- und Tab-Verwaltungsergebnissen hinzu
var result = HandleBrowserAction(toolUse.Name, toolUse.Input);
toolResults.Add(
new ToolResultBlockParam(toolUse.ID) { Content = result, ToolsetName = "browser" }
);
}
catch (Exception e)
{
failed = true;
toolResults.Add(
new ToolResultBlockParam(toolUse.ID)
{
Content = $"Error: {e.Message}",
IsError = true,
ToolsetName = "browser",
}
);
}
}
return toolResults;
}
```
```go Go
const notExecuted = "Not executed: an earlier action in this turn failed."
// browserToolResult erstellt das Ergebnis für eine Browser-Aktion. Anders als ein
// gewöhnliches Tool-Ergebnis muss es den Toolset-Namen zurückgeben. Ein echter Executor fügt
// außerdem einen browser_state-Block zu Navigations- und Tab-Verwaltungsergebnissen hinzu.
func browserToolResult(toolUseID string, content []anthropic.ToolResultBlockParamContentUnion, isError bool) anthropic.ContentBlockParamUnion {
result := anthropic.ToolResultBlockParam{
ToolUseID: toolUseID,
ToolsetName: anthropic.String("browser"),
Content: content,
}
if isError {
result.IsError = anthropic.Bool(true)
}
return anthropic.ContentBlockParamUnion{OfToolResult: &result}
}
// processToolCalls führt die Browser-Aktionen in Claudes Antwort der Reihe nach aus und
// erstellt ein tool_result pro tool_use-Block. Nach dem ersten Fehler überspringt es
// den Rest: Claude hat sie unter der Annahme geplant, dass die vorherigen Aktionen erfolgreich waren.
func processToolCalls(response *anthropic.Message) []anthropic.ContentBlockParamUnion {
var toolResults []anthropic.ContentBlockParamUnion
failed := false
for _, block := range response.Content {
switch variant := block.AsAny().(type) {
case anthropic.ToolUseBlock:
// Dieses Beispiel deklariert nur das Browser-Toolset; leite andere Tools hierher, falls du sie hinzufügst.
if variant.ToolsetName != "browser" {
continue
}
if failed {
toolResults = append(toolResults, browserToolResult(variant.ID, textContent(notExecuted), true))
continue
}
var input map[string]any
var content []anthropic.ToolResultBlockParamContentUnion
err := json.Unmarshal(variant.Input, &input)
if err == nil {
content, err = handleBrowserAction(variant.Name, input)
}
if err != nil {
failed = true
content = textContent("Error: " + err.Error())
}
toolResults = append(toolResults, browserToolResult(variant.ID, content, err != nil))
}
}
return toolResults
}
```
```java Java
/** The exact text the toolset contract prescribes for member calls skipped after a failure. */
static final String HALT_TEXT = "Not executed: an earlier action in this turn failed.";
/** Every result answering a browser toolset member echoes toolset_name. */
ToolResultBlockParam.Builder browserResult(ToolUseBlock toolUse) {
return ToolResultBlockParam.builder()
.toolUseId(toolUse.id())
.toolsetName("browser");
}
/**
* Run the browser actions in Claude's response in order and build one
* tool_result per tool_use block. After the first failure, skip the rest:
* Claude planned them assuming the earlier actions succeeded.
*/
List processToolCalls(Message response) {
List toolResults = new ArrayList<>();
boolean failed = false;
for (ContentBlock block : response.content()) {
// Dieses Beispiel deklariert nur das Browser-Toolset; leite andere Tools hierher, falls du sie hinzufügst.
if (!block.isToolUse() || !block.asToolUse().toolsetName().equals(Optional.of("browser"))) {
continue;
}
ToolUseBlock toolUse = block.asToolUse();
ToolResultBlockParam result;
if (failed) {
result = browserResult(toolUse).content(HALT_TEXT).isError(true).build();
} else {
try {
Map input =
(Map) toolUse._input().asObject().get();
ToolResultBlockParam.Content output = handleBrowserAction(toolUse.name(), input);
// Ein echter Executor fügt außerdem einen browser_state-Block zu Navigations- und
// Tab-Verwaltungsergebnissen hinzu; siehe „Tabs mit browser_state verfolgen“ auf dieser Seite.
result = browserResult(toolUse).content(output).build();
} catch (RuntimeException e) {
failed = true;
result = browserResult(toolUse).content("Error: " + e.getMessage()).isError(true).build();
}
}
toolResults.add(ContentBlockParam.ofToolResult(result));
}
return toolResults;
}
```
```php PHP
const HALT_TEXT = 'Not executed: an earlier action in this turn failed.';
function processToolCalls(Message $response): array
{
$toolResults = [];
$failed = false;
foreach ($response->content as $block) {
// Dieses Beispiel deklariert nur das Browser-Toolset; leite andere Tools hierher, falls du sie hinzufügst.
if (!($block instanceof \Anthropic\Messages\ToolUseBlock) || $block->toolsetName !== 'browser') {
continue;
}
$result = ['type' => 'tool_result', 'tool_use_id' => $block->id, 'toolset_name' => 'browser'];
if ($failed) {
// Ein Batch stoppt beim ersten Fehler; die restlichen Aktionen werden ohne Ausführung beantwortet
$toolResults[] = [...$result, 'content' => HALT_TEXT, 'is_error' => true];
continue;
}
try {
// Ein echter Executor gibt bei Navigations- und Tab-Verwaltungsergebnissen auch einen browser_state-Block zurück
$toolResults[] = [...$result, 'content' => handleBrowserAction($block->name, $block->input)];
} catch (\Throwable $e) {
$failed = true;
$toolResults[] = [...$result, 'content' => 'Error: ' . $e->getMessage(), 'is_error' => true];
}
}
return $toolResults;
}
```
```ruby Ruby
NOT_EXECUTED = "Not executed: an earlier action in this turn failed."
# Führe die Browser-Aktionen in Claudes Antwort der Reihe nach aus und erstelle ein
# tool_result pro tool_use-Block. Nach dem ersten Fehler den Rest überspringen:
# Claude hat sie unter der Annahme geplant, dass die vorherigen Aktionen erfolgreich waren.
def process_tool_calls(response)
tool_results = []
failed = false
response.content.each do |block|
# Dieses Beispiel deklariert nur das Browser-Toolset; leite andere Tools hierher,
# falls du sie hinzufügst.
next unless block.type == :tool_use && block.toolset_name == "browser"
result = { type: "tool_result", tool_use_id: block.id, toolset_name: "browser" }
if failed
result.update(content: NOT_EXECUTED, is_error: true)
else
begin
# Ein String oder Content-Blöcke für einen Screenshot. Ein echter Executor fügt außerdem
# einen browser_state-Block zu Navigations- und Tab-Verwaltungsergebnissen hinzu.
result[:content] = handle_browser_action(block.name, block.input)
rescue => e
result.update(content: "Error: #{e.message}", is_error: true)
failed = true
end
end
tool_results << result
end
tool_results
end
```
Leite jeden Block anhand des Paars (`toolset_name`, `name`) weiter statt nur anhand von `name`, da ein benutzerdefiniertes Tool in derselben Anfrage den Namen eines Members teilen kann; [Client-Toolsets](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference#client-toolsets) beschreibt die Teile dieses Vertrags, die beide Toolsets gemeinsam haben. Wenn Claude einen Member benennt, den dein Executor nicht implementiert, oder einen, den du deaktiviert hast, beantworte diesen Block mit einem [Fehlerergebnis](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#return-errors-from-your-executor), statt ihn zu verwerfen.
Wenn du die Antwort streamst, kommt der `input` jedes Members als ein vollständiges `input_json_delta` statt als Fragmente an, warte also, bis der Zug beendet ist, bevor du den Batch ausführst.
### Batch-Aktionen
Ein Zug mit mehreren Member-Aufrufen ist eine „batch action“ (Batch-Aktion): Führe die Aufrufe in der Reihenfolge aus, in der sie erscheinen, stoppe beim ersten Fehlschlag und beantworte jeden späteren Aufruf mit `is_error: true` und dem exakten Text `Not executed: an earlier action in this turn failed.` Ein Batch verwendet dieselbe Antwortform wie [parallele Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/parallel-tool-use); der Unterschied ist, dass du die Blöcke der Reihe nach statt gleichzeitig ausführst. Hier klickt Claude in einem Zug auf das zuvor gefundene Suchfeld, tippt eine Abfrage und drückt Enter:
```json
{
"role": "assistant",
"content": [
{
"type": "tool_use",
"id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV",
"name": "left_click",
"toolset_name": "browser",
"input": { "target": { "type": "ref", "ref": "ref_3" } }
},
{
"type": "tool_use",
"id": "toolu_01Ez4kLb1nQ2vXo8sJ9pWm3c",
"name": "type",
"toolset_name": "browser",
"input": { "text": "install" }
},
{
"type": "tool_use",
"id": "toolu_01FkP8rTz6uYh2mNq4LsXw7v",
"name": "key",
"toolset_name": "browser",
"input": { "text": "Enter" }
}
]
}
```
Deine Anwendung gibt drei `tool_result`-Blöcke in einer `user`-Nachricht zurück, die jeweils `toolset_name` und eine kurze Textbestätigung wie `Clicked element ref_3.` tragen. Das Drücken von Enter lädt eine Ergebnisseite, daher trägt das `key`-Ergebnis auch einen `browser_state`-Block mit der aktualisierten URL des Tabs ([Tab-Kontext auf anderen Ergebnissen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#tab-context-on-other-results)). Wäre der Klick stattdessen fehlgeschlagen, würde sein Ergebnis deinen Fehlertext tragen und die anderen beiden Ergebnisse würden den Halt-Text tragen, wie unter [Fehler aus deinem Executor zurückgeben](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#return-errors-from-your-executor) gezeigt.
Du musst nicht nach jedem Aufruf einen Screenshot zurückgeben. Claude beendet einen Batch typischerweise mit einem Beobachtungsaufruf (`screenshot`, `read_page` oder `get_page_text`), und deine Anwendung kann auch ihre eigene Beobachtung, etwa einen frischen Screenshot oder Barrierefreiheitsbaum, als zusätzlichen Inhaltsblock an das letzte Ergebnis im Batch anhängen, um einen Roundtrip zu sparen. Da ein Tab-Management-Ergebnis genau ein `browser_state`-Block sein muss, hänge sie an das letzte Ergebnis an, das kein Tab-Management-Aufruf ist.
Wenn dein Executor nur einen Aufruf pro Roundtrip ausführen kann, setze `disable_parallel_tool_use` in `tool_choice` auf `true`, und Claude gibt höchstens einen Member-Aufruf pro Zug zurück, auf Kosten von mehr Roundtrips ([Parallele Tool-Nutzung deaktivieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/parallel-tool-use#disable-parallel-tool-use)). Der Rest des Vertrags unter [Batch-Aktionen für das Computer-Use-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#batch-actions) gilt weiterhin, einschließlich eines `tool_result` für jedes `tool_use` in der nächsten `user`-Nachricht, mit zwei Ausnahmen: dem Halt-Text und dem, was der `content` eines erfolgreichen Ergebnisses enthält. Der Ergebnisinhalt folgt stattdessen [Member-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#member-tools) auf dieser Seite: Ein `new_tab`-, `switch_tab`-, `close_tab`- oder `list_tabs`-Ergebnis ist genau ein `browser_state`-Block ohne Text oder Bild ([Tab-Management-Ergebnisse](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#tab-management-results)), und das Ergebnis jedes anderen Members kann seinem Text oder Bild einen `browser_state`-Block hinzufügen ([Tab-Kontext auf anderen Ergebnissen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#tab-context-on-other-results)). Wo Cache-Breakpoints innerhalb eines Batches wirksam werden, ist in der `cache_control`-Zeile der [Tool-Parameter](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#tool-parameters) des Computer-Use-Tools beschrieben.
### Ziele und Koordinaten
Member-Tools, die auf eine Position einwirken, nehmen ein `target`-Objekt entgegen, das entweder eine Viewport-Pixel-Koordinate oder eine Referenz auf ein Element ist, das `read_page` oder `find` zurückgegeben hat. Die Tabellen unter [Member-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#member-tools) schreiben `Target` für einen Parameter, der beide Formen akzeptiert.
| Form | `target.type` | Felder | Akzeptiert von |
| ------------------ | -------------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CoordinateTarget` | `"coordinate"` | `x`, `y` (Ganzzahlen, Viewport-Pixel) | `left_click`, `right_click`, `middle_click`, `double_click`, `triple_click`, `hover`, `left_click_drag` (`from` und `target`), `left_mouse_down`, `left_mouse_up`, `mouse_move`, `scroll` |
| `RefTarget` | `"ref"` | `ref` (eine Elementreferenz wie `"ref_2"`) | `left_click`, `right_click`, `middle_click`, `double_click`, `triple_click`, `hover`, `scroll_to`, `form_input`, `file_upload` |
**Koordinaten sind Viewport-Pixel**, der Pixelraum eines `screenshot` des gesamten Viewports mit dem Ursprung oben links auf der gerenderten Seite; es gibt keinen umgebenden Desktop oder Fensterrahmen. Das Toolset deklariert keine Anzeigeabmessungen, und Claude leitet die Viewport-Größe aus den Screenshots ab, die du zurückgibst, halte sie also in einer einheitlichen Größe. Ein `zoom` ändert den Rahmen nicht, daher sind seine `region` und alle Koordinaten, die Claude nach dem Betrachten des gezoomten Bildes ausgibt, weiterhin Pixel des gesamten Viewports.
**Screenshots müssen in die Bildlimits passen.** Die API skaliert Toolset-Bilder nicht herunter: Ein Screenshot oder Zoom-Bild, das die [Bildgrößenlimits](https://platform.claude.com/docs/de/build-with-claude/vision#evaluate-image-size) deines Modells überschreitet, oder das strengere Limit pro Bild, das gilt, sobald eine Anfrage [mehr als 20 Bilder](https://platform.claude.com/docs/de/build-with-claude/vision#request-limits) enthält, wird abgelehnt. Skaliere vor der Rückgabe und skaliere Claudes Koordinaten um den Kehrwert deines Faktors wieder hoch, bevor du sie weiterleitest ([Screenshots passend zu den Bildlimits dimensionieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions)).
**Elementreferenzen stammen aus `read_page` und `find`.** Jedes Element in ihrer Ausgabe trägt ein Tag wie `[ref_2]`, wie im Schnellstart-Ergebnis:
```text wrap
link "Documentation" [ref_1]
link "Getting started" [ref_2]
textbox "Search docs" [ref_3]
button "Search" [ref_4]
link "Pricing" [ref_5]
```
Claude gibt eine Referenz als `{"type": "ref", "ref": "ref_2"}`-Ziel bei einem späteren Klick-, `hover`-, `scroll_to`-, `form_input`- oder `file_upload`-Aufruf zurück, oder als `ref`-Parameter bei `read_page`, um einen Teilbaum zu lesen. Dein Executor vergibt die Referenzen, hält die Zuordnung von jeder einzelnen zum zugrunde liegenden Knoten (eine Barrierefreiheitsknoten-ID, ein gespeicherter Selektor oder Äquivalentes) und wirkt auf diesen Knoten ein, wenn eine Referenz zurückkommt.
Referenzen sind auf den Tab beschränkt, der sie erzeugt hat, und bleiben gültig, bis dieser Tab navigiert oder sich sein DOM wesentlich ändert. Die API kann eine veraltete oder unbekannte Referenz nicht erkennen, gib also, wenn Claude eine Referenz übergibt, die dein Executor nicht mehr erkennt, ein Fehlerergebnis wie `Error: ref_3 is stale or not found on the current page. Re-read the page to get fresh references.` zurück. Claude liest die Seite dann erneut. Nummeriere Referenzen, die du für einen Tab bereits ausgegeben hast, nicht neu, bis er navigiert, da dies Referenzen, die Claude noch hält, stillschweigend ungültig macht.
Claude verwendet beide Zielstile und wechselt zwischen ihnen je nachdem, was die Seite bereitstellt; dein Prompt und das, was dein Executor zurückgibt, steuern die Wahl:
* **Bevorzuge Referenzen, wo die Seite einen brauchbaren Barrierefreiheitsbaum hat.** Eine Referenz überlebt Layoutverschiebungen und Reflows, die Pixelkoordinaten fragil machen, und lässt Claude auf Steuerelemente einwirken, die mit einem Zeiger schwer zu treffen sind.
* **Weiche auf Koordinaten aus für Inhalte, die der Baum nicht beschreibt.** Canvas-gerenderte Oberflächen, eingebettete Video- oder Remote-Desktop-Flächen, stark virtualisierte Listen und Elemente innerhalb von Cross-Origin-Iframes haben oft keinen nützlichen Knoten, daher arbeitet Claude mit `screenshot` und `zoom` und klickt per Koordinate; dein Executor löst auf, in welchem Frame eine Koordinate landet.
* **Begrenze Lesevorgänge und lies den Baum, bevor du einen Screenshot machst.** Auf großen Seiten gibt `read_page` mit `filter: "interactive"` oder dem `ref` eines Containers einen fokussierten Teilbaum zurück, und ein Baum-Lesevorgang einer typischen Seite kostet oft weniger Input-Token als ein Screenshot, während er Claude Referenzen gibt, auf die es sofort einwirken kann. Screenshots bleiben die richtige Beobachtung, wenn visuelles Layout, Bilder oder Rendering-Zustand wichtig sind.
## Sicherheitsüberlegungen
Browser Use birgt Risiken, die Standard-API-Funktionen nicht haben, da Claude Inhalte aus dem offenen Web liest und darauf handelt, wo jede Seite Text enthalten kann, der geschrieben wurde, um es zu manipulieren.
Um diese Risiken zu verringern, triff Vorkehrungen wie die folgenden:
1. Führe den Browser und deinen Executor in einem dedizierten Container oder einer virtuellen Maschine mit minimalen Berechtigungen aus, mit einem frischen Profil, das keine Anmeldedaten enthält, und ohne Zugriff auf sensible Dateisysteme oder interne Netzwerke; isoliere jedes Tool, das du daneben ausführst, auf dieselbe Weise.
2. Beschränke die Hosts, die der Browser erreichen kann, auf eine Domain-Allowlist, die auf Netzwerkebene durchgesetzt und in deinem `navigate`-Handler nach Weiterleitungen erneut geprüft wird, und blockiere Loopback-, Link-Local- und private Bereiche, sofern die Aufgabe sie nicht benötigt.
3. Behandle alles, was eine Seite liefert, als nicht vertrauenswürdige Eingabe, einschließlich der Tab-Titel und URLs sowie `url`, `path` und `error` jedes Downloads, die du in einem [`browser_state`](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#track-tabs-and-page-state)-Block meldest, und baue Seitenlesevorgänge aus dem auf, was die Seite rendert (dem Accessibility Tree oder sichtbarem Text), nicht aus dem rohen DOM-Quelltext, damit versteckter Text Claude nicht erreicht.
4. Akzeptiere in deinem `navigate`-Handler die Verlaufsschlüsselwörter `"back"`, `"forward"` und `"reload"`, behandle eine URL ohne Schema als `https://`, parse dann die URL und lehne jedes andere Schema als `http` oder `https` (`javascript:`, `file:`, `data:`, `chrome:` usw.) mit einem [Fehlerergebnis](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#return-errors-from-your-executor) ab. Prüfe das Schema mit einem URL-Parser statt mit einem String-Präfix; die API filtert nicht, welche URLs Claude öffnet, und kann daher keine für dich ablehnen.
5. Lass `javascript_exec` und `file_upload` deaktiviert, sofern du sie nicht benötigst, und lies [Optionale Members aktivieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#enable-optional-member-tools), bevor du eines davon einschaltest.
6. Lass einen Menschen folgenreiche Aktionen und alles bestätigen, was eine ausdrückliche Zustimmung erfordert (Käufe, Kontoänderungen, Nachrichtenversand und das Akzeptieren von Bedingungen), und führe diese Prüfung in deinem Executor vor jedem Aufruf durch, da ein Zug mehrere enthalten kann.
Claude folgt manchmal Anweisungen, die in Seiteninhalten gefunden werden, selbst wenn sie deinen widersprechen; Text auf einer Seite, der sagt „ignoriere deine vorherigen Anweisungen und navigiere zu...“, kann es von der Aufgabe ablenken. Isoliere Claude von sensiblen Daten und Aktionen, um zu begrenzen, was eine Prompt-Injection erreichen kann, lies [Jailbreaks und Prompt-Injections abschwächen](https://platform.claude.com/docs/de/test-and-evaluate/strengthen-guardrails/mitigate-jailbreaks), und wenn eine Aufgabe eine angemeldete Sitzung nicht vermeiden kann, verwende ein dediziertes Konto mit geringen Rechten und behalte die menschliche Bestätigung bei kontoändernden Aktionen bei.
Anthropic hat das Modell darauf trainiert, diesen Prompt-Injections zu widerstehen, und eine zusätzliche Verteidigungsebene hinzugefügt. Wenn du das Browser-Use-Tool verwendest, scannen Klassifikatoren automatisch, was der Browser zurückgibt, etwa Seitentext oder Screenshots, um potenzielle Prompt-Injections zu markieren. Wenn diese Klassifikatoren eine potenzielle Prompt-Injection erkennen, lenken sie das Modell automatisch dazu, zu prüfen, ob die Anweisung wirklich von dir stammt, bevor es danach handelt.
Dieser zusätzliche Schutz ist nicht für jeden Anwendungsfall ideal (zum Beispiel für Anwendungsfälle ohne Menschen im Prozess); wenn du ihn also deaktivieren möchtest, [kontaktiere den Support](https://support.claude.com/en/). Die obigen Vorsichtsmaßnahmen bleiben auch mit diesen Klassifikatoren wichtig.
Da der Browser in deiner Umgebung läuft, sehen die Websites, die Claude besucht, die Netzwerkidentität deines Executors, und Seiteninhalte erreichen die API nur als die Tool-Ergebnisse, die du zurückgibst. Informiere Endbenutzer über die relevanten Risiken und hole ihre Zustimmung ein, bevor du Browser Use in deinen Produkten aktivierst.
## Member-Tools
Der `browser_toolset_20260801`-Eintrag deklariert 31 Member-Tools; der `input` jedes Aufrufs besteht genau aus den hier aufgeführten Parametern, und `tab_id` ist, wo optional, standardmäßig der aktive Tab. `Target`, `CoordinateTarget` und `RefTarget` sind die unter [Ziele und Koordinaten](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#targets-and-coordinates) beschriebenen Formen. Vier Members (`javascript_exec`, `file_upload`, `read_console` und `read_network`) sind standardmäßig deaktiviert und erscheinen nur, wenn du [sie aktivierst](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#enable-optional-member-tools). Die in der Zeile jedes Members genannten Eingabegrenzen und Ausgabekonventionen werden Claude mitgeteilt, nicht von der API durchgesetzt, validiere also Eingaben (einschließlich Koordinaten gegen deinen Viewport) und wende die Konventionen in deinem Executor an.
Nur `screenshot` und `zoom` erfordern einen [`image`-Block](https://platform.claude.com/docs/de/agents-and-tools/tool-use/handle-tool-calls#handling-results-from-client-tools) in ihrem Ergebnis, und die vier Tab-Management-Members (`new_tab`, `list_tabs`, `switch_tab` und `close_tab`) geben genau einen `browser_state`-Block zurück (siehe [Tab-Management-Ergebnisse](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#tab-management-results)). Jeder andere Member gibt einen `text`-Block zurück: entweder eine kurze Bestätigung wie `Clicked element ref_2.` oder die Ausgabe des Members. Jedes Ergebnis außer einem Tab-Management-Ergebnis kann auch einen `image`-Block tragen, typischerweise einen nach der Aktion aufgenommenen Screenshot, sodass Claude das Resultat ohne separaten `screenshot`-Aufruf sieht; [Batch-Aktionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#batch-actions) zeigt, wo man einen in einem Batch anhängt. Ein Member-`tool_result` darf nur `text`-, `image`- und `browser_state`-Inhaltsblöcke enthalten.
### Navigation und Erfassung
| Member | Eingabe | Beschreibung |
| ------------ | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `navigate` | `url`, `tab_id?` | Lade eine `http`- oder `https`-URL oder bewege dich mit `"back"`, `"forward"` oder `"reload"` durch die History. Behandle eine URL ohne Schema als `https://` und lehne jedes andere Schema mit einem Fehlerergebnis ab. Gib eine kurze Bestätigung zurück, plus einen `browser_state`-Block, wenn sich URL oder Titel des Tabs geändert haben. |
| `screenshot` | `tab_id?` | Erfasse den Viewport und gib einen `image`-Block zurück. |
| `zoom` | `region`, `tab_id?` | Gib ein zugeschnittenes, hochskaliertes `image` von `region` zurück, angegeben als `[x0, y0, x1, y1]` in Viewport-Pixeln, zur genaueren Betrachtung von kleinem Text oder Steuerelementen. |
### Zeiger
| Member | Eingabe | Beschreibung |
| ----------------- | --------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `left_click` | `target: Target`, `modifiers?`, `tab_id?` | Linksklick auf eine Koordinate oder ein referenziertes Element. `modifiers` ist eine während des Klicks gehaltene Tastenkombination, zum Beispiel `"shift"` oder `"ctrl+shift"`. |
| `right_click` | `target: Target`, `modifiers?`, `tab_id?` | Rechtsklick auf eine Koordinate oder ein Element. |
| `middle_click` | `target: Target`, `modifiers?`, `tab_id?` | Mittelklick auf eine Koordinate oder ein Element. |
| `double_click` | `target: Target`, `modifiers?`, `tab_id?` | Doppelter Linksklick auf eine Koordinate oder ein Element. |
| `triple_click` | `target: Target`, `modifiers?`, `tab_id?` | Dreifacher Linksklick auf eine Koordinate oder ein Element, was typischerweise eine Zeile oder einen Absatz auswählt. |
| `hover` | `target: Target`, `tab_id?` | Bewege den Zeiger über eine Koordinate oder ein Element, ohne zu klicken. |
| `left_click_drag` | `from: CoordinateTarget`, `target: CoordinateTarget`, `tab_id?` | Drücke bei `from`, ziehe zu `target` und lasse los. |
| `left_mouse_down` | `target: CoordinateTarget`, `tab_id?` | Drücke und halte die linke Taste an einer Koordinate; kombiniere mit `left_mouse_up` für ein benutzerdefiniertes Ziehen. |
| `left_mouse_up` | `target: CoordinateTarget`, `tab_id?` | Lasse die linke Taste an einer Koordinate los. |
| `mouse_move` | `target: CoordinateTarget`, `tab_id?` | Bewege den Zeiger zu einer Koordinate. |
| `scroll` | `target: CoordinateTarget`, `scroll_direction`, `scroll_amount?`, `tab_id?` | Scrolle an einer Viewport-Position. `scroll_direction` ist `"up"`, `"down"`, `"left"` oder `"right"`; `scroll_amount` ist in Scrollrad-Rasten angegeben, 1 bis 10, Standard 3. |
| `scroll_to` | `target: RefTarget`, `tab_id?` | Scrolle ein referenziertes Element in den sichtbaren Bereich. |
### Tastatur und Timing
| Member | Eingabe | Beschreibung |
| ---------- | ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | `text`, `tab_id?` | Tippe eine wörtliche Zeichenkette am aktuellen Fokus. |
| `key` | `text`, `repeat?`, `tab_id?` | Drücke eine Taste oder Tastenkombination. `text` ist eine einzelne Taste (`"Enter"`), eine mit `+` verbundene Kombination (`"ctrl+a"`) oder eine durch Leerzeichen getrennte Sequenz (`"Backspace Backspace"`); `repeat` ist 1 bis 100, Standard 1. |
| `hold_key` | `text`, `duration`, `tab_id?` | Halte eine Taste oder Kombination für `duration` Sekunden, 0 bis 30. |
| `wait` | `duration`, `tab_id?` | Pausiere für `duration` Sekunden, 0 bis 30. |
### Seiten lesen
| Member | Eingabe | Beschreibung |
| --------------- | -------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `read_page` | `filter?`, `depth?`, `ref?`, `tab_id?` | Gib den Barrierefreiheitsbaum der Seite als Text zurück, wobei jedes Element mit einer Referenz wie `[ref_2]` getaggt ist. Ohne `filter` gib jedes sichtbare Element zurück; mit `"interactive"` nur sichtbare interaktive Elemente; mit `"all"` auch Elemente außerhalb des Viewports. `depth` begrenzt die Baumtiefe (Minimum 1, Standard 15) und `ref` beschränkt den Lesevorgang auf den Teilbaum dieses Elements. Begrenze die Ausgabe auf 50.000 Zeichen und sage dies im Text; Claude grenzt dann mit einer kleineren `depth` oder einem `ref` ein. |
| `find` | `query`, `tab_id?` | Suche nach Elementen, die einer natürlichsprachlichen Beschreibung wie `"search field"` oder `"add to cart button"` entsprechen, und gib bis zu 20 Treffer im selben getaggten Format wie `read_page` zurück. |
| `get_page_text` | `tab_id?` | Gib den sichtbaren Text der Seite als Klartext zurück, wobei der Hauptartikelinhalt priorisiert wird; geeignet für Artikel, Dokumentation und andere textlastige Seiten. |
### Formulare und Dateien
| Member | Eingabe | Beschreibung |
| ----------------------------------------- | --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `form_input` | `target: RefTarget`, `value`, `tab_id?` | Setze den Wert eines Formularelements direkt. `value` ist ein `string`, `number` oder `boolean`; verwende einen `boolean` für Checkboxen und den Wert oder sichtbaren Text einer Option für Selects. |
| `file_upload` (standardmäßig deaktiviert) | `target: RefTarget`, `paths?`, `document_ids?`, `tab_id?` | Setze die Dateien eines Datei-Eingabeelements aus `paths` im Dateisystem des Executors, aus `document_ids`, die deine Anwendung bereitgestellt hat, oder aus beidem; mindestens eines ist erforderlich. Siehe [Dateien hochladen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#upload-files). |
### Diagnose und Scripting
| Member | Eingabe | Beschreibung |
| --------------------------------------------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `read_console` (standardmäßig deaktiviert) | `tab_id?` | Gib die seit dem letzten Lesevorgang angesammelten Konsoleneinträge des Tabs (Log-, Warn- und Fehlerzeilen) zurück, eine Zeile pro Eintrag. Siehe [Konsolen- und Netzwerkaktivität lesen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#read-console-and-network-activity). |
| `read_network` (standardmäßig deaktiviert) | `tab_id?` | Gib die Netzwerkanfragen des Tabs (Methode, URL, Status, MIME-Typ, Timing) seit dem letzten Lesevorgang zurück, eine Zeile pro Eintrag. |
| `javascript_exec` (standardmäßig deaktiviert) | `text`, `tab_id?` | Führe `text` als JavaScript im Seitenkontext aus und gib den Wert des letzten Ausdrucks als Text zurück. Siehe [Optionale Members aktivieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#enable-optional-member-tools). |
### Tab-Management
| Member | Eingabe | Beschreibung |
| ------------ | ----------------------- | ---------------------------------------------- |
| `new_tab` | (keine) | Öffne einen Tab und mache ihn zum aktiven Tab. |
| `list_tabs` | (keine) | Melde das Tab-Inventar. |
| `switch_tab` | `tab_id` (erforderlich) | Mache `tab_id` zum aktiven Tab. |
| `close_tab` | `tab_id` (erforderlich) | Schließe `tab_id`. |
Bei Erfolg gibt jeder dieser Members genau einen `browser_state`-Block und keinen Text oder kein Bild zurück; siehe [Tab-Management-Ergebnisse](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#tab-management-results).
## Das Toolset konfigurieren
Neben `type` akzeptiert der Toolset-Eintrag `configs`, `cache_control` und `allowed_callers`; die Regeln, die diese Felder mit dem Computer-Use-Toolset teilen, sind unter [Client-Toolsets](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference#client-toolsets) aufgeführt, und dieser Abschnitt behandelt die browserspezifischen Standardwerte. `configs` ist ein Objekt mit Member-Namen als Schlüsseln, und der Wert jedes Members akzeptiert zwei Felder:
| Feld | Standard | Bedeutung |
| --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `enabled` | `true`, außer `false` für die vier [optionalen Members](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#enable-optional-member-tools) | Ob der Member Claude angeboten wird. |
| `defer_loading` | `false` | Ob die Definition des Toolsets für die Tool-Suche zurückgestellt wird. Muss bei jedem aktivierten Member zum selben Wert aufgelöst werden. Wenn die vier optionalen Members deaktiviert bleiben, bedeutet das Zurückstellen des Toolsets, es auf den anderen 27 zu setzen; siehe [Client-Toolsets](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference#client-toolsets). |
### Member-Tools aktivieren oder deaktivieren
Führe in `configs` nur die Members auf, die du ändern möchtest; jeder Member, den du weglässt, behält seinen Standardwert. Zum Beispiel schaltet ein Executor, der Konsolen-Lesevorgänge, aber keine Low-Level-Zeiger- oder Tastenhalte-Steuerung implementiert, `read_console` ein und hält drei Members zurück:
```json
{
"type": "browser_toolset_20260801",
"configs": {
"read_console": { "enabled": true },
"left_mouse_down": { "enabled": false },
"left_mouse_up": { "enabled": false },
"hold_key": { "enabled": false }
}
}
```
Ein deaktivierter Member verschwindet aus der Definition, die Claude sieht; das garantiert nicht, dass Claude ihn nie benennt, daher beantwortet dein Executor einen solchen Aufruf dennoch mit einem [Fehlerergebnis](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#return-errors-from-your-executor).
### Mit anderen Tools kombinieren
Deklariere das Browser-Use-Tool neben deinen eigenen Tools und anderen von Anthropic bereitgestellten Tools im selben `tools`-Array. Ein benutzerdefiniertes Tool darf den Namen eines Members teilen (zum Beispiel dein eigenes `navigate`), da `toolset_name` Claudes Aufrufe unterscheidet, aber kein anderer Eintrag darf `browser` heißen, und eine Anfrage darf nur einen Browser-Toolset-Eintrag enthalten.
Du kannst es auch neben dem [Computer-Use-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool) deklarieren, entweder dem Toolset oder einer früheren Computer-Use-Tool-Version. Die beiden arbeiten unabhängig, jedes in seinem eigenen Koordinatenrahmen (hier Viewport-Pixel, dort Desktop-Screenshot-Pixel), und Claudes Aufrufe an Members, die einen Namen teilen, wie `screenshot` oder `key`, werden durch `toolset_name` unterschieden.
## Optionale Members aktivieren
Vier Member-Tools sind standardmäßig deaktiviert: `javascript_exec` und `file_upload`, weil sie erweitern, wozu eine manipulierte Seite Claude bringen könnte, und `read_console` und `read_network`, weil nicht jeder Browserautomatisierungs-Stack diese Logs liefern kann und sie erweitern, welche seitenkontrollierten Inhalte Claude erreichen. Aktiviere jedes einzelne mit `configs` (zum Beispiel `"configs": {"file_upload": {"enabled": true}}`) nur, wenn dein Executor es implementiert und die Aufgabe es benötigt.
### Dateien hochladen
`file_upload` setzt die Dateien eines ``-Elements direkt, was zuverlässiger ist als das Steuern eines nativen Dateiauswahldialogs. Sein `target` ist ausschließlich eine Referenz, da der Aufruf die Identität des Elements benötigt, und es nimmt `paths`, `document_ids` oder beides entgegen:
* `paths` sind Dateipfade im Dateisystem des Executors, für Bereitstellungen, in denen der Executor die Dateien deiner Anwendung direkt lesen kann (dieselbe Bedingung, unter der du den `path` eines Downloads befüllst).
* `document_ids` sind Bezeichner für Dateien, die deine Anwendung für den Browser bereitgestellt hat, für Bereitstellungen, in denen er das nicht kann. Deine Anwendung definiert, was die Bezeichner bedeuten; beschränke ihre Auflösung so, wie du `paths` beschränkst, auf für diese Aufgabe bereitgestellte Dateien.
```json
{
"type": "tool_use",
"id": "toolu_01N7gVzFEfZjLjgsYwnrPgrF",
"name": "file_upload",
"toolset_name": "browser",
"input": {
"target": { "type": "ref", "ref": "ref_12" },
"paths": ["/home/user/uploads/summary.pdf"],
"tab_id": "tab-2"
}
}
```
Claude schreibt diese Pfade, während es nicht vertrauenswürdige Seiten liest, daher würde eine uneingeschränkte Implementierung es einer bösartigen Seite ermöglichen, den Upload jeder Datei, die der Executor lesen kann, auf eine von der Seite kontrollierte Website zu lenken. Aktiviere den Member nur, wenn dein Executor jeden Pfad auflöst (Symlinks und `..`-Segmenten folgend) und nichts außerhalb eines dedizierten, auf der Allowlist stehenden Upload-Verzeichnisses akzeptiert, das nur für die Aufgabe bestimmte Dateien enthält. Verwende dafür nicht das Download-Verzeichnis des Browsers wieder; wenn du das tust, wird jede Datei, die eine Seite den Browser herunterladen lässt, hochladbar.
### JavaScript in der Seite ausführen
`javascript_exec` führt den Ausdruck, den Claude schreibt, im Kontext der Seite aus und gibt den Wert des letzten Ausdrucks als Text zurück; Claude schreibt einen Ausdruck, keine `return`-Anweisung. Der Code läuft mit den vollen Rechten der Seite, einschließlich ihrer Cookies, ihres Speichers und Same-Origin-Anfragen. Aktiviere den Member nur in Sitzungen, die keine Anmeldedaten enthalten, halte die Domain-Allowlist aus den [Sicherheitsüberlegungen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#security-considerations) in Kraft, behandle den zurückgegebenen Wert als nicht vertrauenswürdige Eingabe und protokolliere den Code, den Claude ausgibt.
### Konsolen- und Netzwerkaktivität lesen
`read_console` gibt die Konsoleneinträge des Tabs zurück und `read_network` seine Netzwerkanfragen, jeweils als Text mit einer Zeile pro Eintrag, angesammelt seit dem vorherigen Lesevorgang dieses Tabs. Eine Konsolenzeile trägt einen Log-, Warn- oder Fehlereintrag; eine Netzwerkzeile trägt Methode, URL, Status, MIME-Typ und Timing. Einträge existieren erst ab dem Moment, in dem sich deine Browserautomatisierung an den Tab angehängt hat, daher bedeutet ein leeres Ergebnis nicht, dass ein bereits geöffneter Tab keinen Datenverkehr hatte.
Diese Members lassen Claude eine fehlerhaft funktionierende Seite diagnostizieren (eine fehlgeschlagene Anfrage hinter einem Spinner, ein Skriptfehler hinter einem toten Button), ohne wiederholte Screenshots. Konsolen- und Netzwerkeinträge sind seitenkontrolliert und enthalten oft Geheimnisse wie Token in Anfrage-URLs, schwärze also anmeldedatenähnliche Werte, die du nicht in Claudes Kontext haben möchtest, und kürze sehr lange Einträge, bevor du sie zurückgibst.
## Tabs mit `browser_state` verfolgen
Claude adressiert Tabs über `tab_id`, deine Anwendung ist die maßgebliche Quelle dafür, welche Tabs existieren, und du meldest diesen Zustand in einem `browser_state`-Inhaltsblock, den Claude nie direkt sieht: Die API rendert den Text, den Claude daraus liest.
```json
{
"type": "browser_state",
"tabs": [
{
"tab_id": "tab-1",
"title": "Documentation",
"url": "https://example.com/docs",
"active": true
},
{ "tab_id": "tab-2", "title": "Pricing", "url": "https://example.com/pricing" }
]
}
```
* `tabs` ist das vollständige Inventar der nach dem Aufruf geöffneten Tabs, kein Delta. Es darf leer sein. Wenn es nicht leer ist, trägt genau ein Eintrag `"active": true`.
* `state_changes` (hier nicht gezeigt) meldet Nebeneffekte des Aufrufs. Dazu gehören ein `tab_opened`-Eintrag für jeden Tab, den der Aufruf geöffnet hat und der bei dessen Abschluss noch geöffnet ist, sowie [Download-Ereignisse](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#report-downloads). Die `tab_id` jedes `tab_opened`-Eintrags muss auch in `tabs` erscheinen. Lass das Feld weg, wenn es nichts zu melden gibt; ein leeres Array wird abgelehnt.
* Sende den Block nur bei Ergebnissen, die einen Aufruf eines Browser-Members beantworten, höchstens einmal pro `tool_result` und niemals bei einem Ergebnis mit `is_error: true`. „Kein Tab-Zustand zu melden" drückst du aus, indem du den Block weglässt.
* Die API rendert `tabs` und alle Download-Einträge in `state_changes` in Text für Claude. Die nächsten beiden Abschnitte und [Downloads melden](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#report-downloads) zeigen diesen Text.
**Du vergibst die `tab_id`-Werte.** Jeder stabile String funktioniert, etwa die Seitenkennung deiner Automatisierungsbibliothek oder dein eigener Zähler, solange du eine `tab_id` nicht wiederverwendest, während ein Tab mit dieser Kennung in einem früheren Ergebnis noch als geöffnet aufgeführt ist. Die API erzwingt diese Limits für den Block:
* Jede `tab_id`, jeder `title` und jede `url` darf höchstens 4.096 Zeichen lang sein, `tab_id` darf nicht leer sein, und keines davon darf Steuerzeichen (einschließlich Zeilenumbrüchen) oder Unicode-Zeilen- oder Absatztrennzeichen enthalten.
* Ein Block darf höchstens 100 Tabs und 200 Zustandsänderungen auflisten.
* Dieselben Limits gelten für die `tab_id`, die Claude an `switch_tab` und `close_tab` übergibt, weil die API sie in den Ergebnistext rendert. Beantworte daher einen Aufruf, dessen `tab_id` sie verletzt, mit einem Fehlerergebnis statt mit einem `browser_state`-Block.
Tab-Titel und URLs stammen von der Seite und werden in Text gerendert, den Claude liest. Sie sind daher eine Angriffsfläche für „prompt injection" (Prompt-Injektion). Die API rendert Tab-URLs unverändert, also bereinige von der Seite gelieferte URLs, bevor du `tabs` befüllst. Doppelte Anführungszeichen und Backslashes in Titeln maskiert die API beim Rendern selbst. Maskiere Titel daher nicht vorab, denn ein vorab maskierter Titel erreicht Claude doppelt maskiert. Verdächtige Titel zu kürzen oder zu verwerfen, lohnt sich trotzdem. Auch `url`, `path` und `error` eines Download-Eintrags werden in Text gerendert, den Claude liest, also behandle sie ebenfalls als nicht vertrauenswürdig. Die API setzt sie in Anführungszeichen und maskiert sie wie Titel. Die Längen- und Zeichengrenzen, die die API erzwingt, sind eine Mindestanforderung, kein Schutz.
### Ergebnisse der Tab-Verwaltung
Bei `new_tab`, `switch_tab`, `close_tab` und `list_tabs` ist der `content` eines erfolgreichen Ergebnisses genau ein `browser_state`-Block ohne Text oder Bild, und die API schreibt den Text, den Claude sieht. Der Block eines `new_tab`-Ergebnisses muss außerdem genau eine `tab_opened`-Zustandsänderung tragen, deren `tab_id` mit dem als `active: true` markierten Eintrag übereinstimmt.
| Member | Text, den Claude sieht |
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------- |
| `switch_tab` | `Switched to tab {tab_id}`, entnommen aus `input.tab_id` des Aufrufs |
| `close_tab` | `Closed tab {tab_id}`, entnommen aus `input.tab_id` des Aufrufs |
| `new_tab` | `Created new tab with tab_id: {tab_id}, URL: {url}. It is now the current tab.`, entnommen aus dem als `active: true` markierten Eintrag |
| `list_tabs` | `Available tabs:` gefolgt von einer Zeile pro Tab, oder `No tabs available`, wenn `tabs` leer ist |
Ein `list_tabs`-Ergebnis, dessen Block zwei Tabs auflistet, von denen der erste aktiv ist, wird wie folgt gerendert, wobei jede Zeile um zwei Leerzeichen eingerückt ist und `(current)` nur an den aktiven Tab angehängt wird:
```text wrap
Available tabs:
• tab_id tab-1: "Documentation" (https://example.com/docs) (current)
• tab_id tab-2: "Pricing" (https://example.com/pricing)
```
Ein Fehlerergebnis für einen dieser Member ist das Gegenteil: gewöhnlicher Fehlertext in `content`, `is_error: true` und kein `browser_state`-Block.
Wenn Claude zum Beispiel `new_tab` aufruft (sein `input` ist leer), öffnet dein Executor den Tab, macht ihn aktiv und gibt das Inventar mit einem `tab_opened`-Eintrag zurück:
```json
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_01WvHSbQVV9j5nWGvTmk4vNL",
"toolset_name": "browser",
"content": [
{
"type": "browser_state",
"tabs": [
{ "tab_id": "tab-1", "title": "Documentation", "url": "https://example.com/docs" },
{ "tab_id": "tab-2", "title": "Pricing", "url": "https://example.com/pricing" },
{ "tab_id": "tab-3", "title": "", "url": "about:blank", "active": true }
],
"state_changes": [{ "type": "tab_opened", "tab_id": "tab-3" }]
}
]
}
]
}
```
Claude sieht `Created new tab with tab_id: tab-3, URL: about:blank. It is now the current tab.` Melde die URL, unter der der Tab geöffnet wurde, wie hier, nicht eine, zu der er später weiterleitet; spätere Ergebnisse melden die dann aktuelle URL des Tabs.
### Tab-Kontext bei anderen Ergebnissen
Bei jedem anderen Member ist der Block optional: Sende ihn, wenn sich die Menge der geöffneten Tabs, der aktive Tab oder der Titel oder die URL eines Tabs geändert hat oder wenn es `state_changes` zu melden gibt, und füge immer das vollständige `tabs`-Inventar bei. Wenn ein Ergebnis sowohl Text als auch einen `browser_state`-Block trägt, hängt die API eine `Tab Context`-Fußzeile an den Text dieses Ergebnisses an, durch eine Leerzeile von deinem Text getrennt, sodass Claude den neuen Zustand ohne separaten `list_tabs`-Aufruf erhält:
```text wrap
Tab Context:
- Executed on tab_id: tab-1
- Available tabs:
• tab_id tab-1: "Documentation" (https://example.com/docs)
• tab_id tab-2: "Pricing" (https://example.com/pricing)
```
`Executed on` benennt den Tab, auf dem der Aufruf lief, also dessen `tab_id`-Eingabe, falls vorhanden, und andernfalls den aktiven Tab, und die Tab-Zeilen der Fußzeile tragen keine `(current)`-Markierung. Hänge diesen Text nicht selbst an; sende den strukturierten Block und lass die API ihn rendern. Die Fußzeile wird dedupliziert, sodass identischer Tab-Zustand bei späteren Ergebnissen nicht erneut gerendert wird und es nichts kostet, den Block großzügig zu befüllen.
In drei Fällen wird keine Fußzeile gerendert, selbst wenn der Block vorhanden ist:
* Bei jedem `zoom`-Ergebnis.
* Bei einem Ergebnis ohne `text`-Block (zum Beispiel einem `screenshot`-Ergebnis, das nur ein Bild enthält). Für ein solches Ergebnis wird nichts gerendert oder gespeichert. Der Tab-Kontext erscheint beim nächsten Ergebnis, das sowohl Text als auch einen `browser_state`-Block enthält. Wenn Claude eine Tab-Änderung schon bei diesem Ergebnis sehen soll, füge dem Bild einen kurzen Textblock hinzu. Eine Ausnahme bildet ein Ergebnis, dessen Block ein [Download-Ereignis](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#report-downloads) meldet. Die API fügt die Download-Zeilen als Textblock hinzu, und die Fußzeile folgt ihnen wie bei jedem Ergebnis mit Text.
* Bei einem Ergebnis mit leerer `tabs`-Liste zu einem Aufruf ohne `tab_id`, weil es keinen Tab gibt, der genannt werden könnte.
Als Claude zum Beispiel früher in dieser Sitzung auf den Link „Pricing“ (`ref_5`) klickte, öffnete die Seite ihn in einem neuen Tab, den Claude nicht angefordert hatte, und ohne Meldung müsste Claude `list_tabs` aufrufen, um ihn zu entdecken. Gib die Bestätigung des Klicks plus einen Block zurück, dessen `state_changes` den geöffneten Tab benennt, und markiere den Tab, den dein Executor aktiv gelassen hat:
```json
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_01EgTXj1FjE2FCTt2zNFWLao",
"toolset_name": "browser",
"content": [
{ "type": "text", "text": "Clicked element ref_5." },
{
"type": "browser_state",
"tabs": [
{
"tab_id": "tab-1",
"title": "Documentation",
"url": "https://example.com/docs",
"active": true
},
{ "tab_id": "tab-2", "title": "Pricing", "url": "https://example.com/pricing" }
],
"state_changes": [{ "type": "tab_opened", "tab_id": "tab-2" }]
}
]
}
]
}
```
Claude sieht `Clicked element ref_5.` gefolgt von der zuvor gezeigten Tab-Context-Fußzeile. Ein Tab, der während eines fehlgeschlagenen Aufrufs geöffnet wurde, erhält keinen `tab_opened`-Eintrag, weil Fehlerergebnisse kein `browser_state` tragen; er erscheint stattdessen im `tabs`-Inventar des nächsten erfolgreichen Ergebnisses. In einem Batch hängst du den Block an das Ergebnis des Aufrufs an, während dessen die Änderung stattfand, und gibst jedem erfolgreichen Tab-Verwaltungsergebnis seinen eigenen Block, selbst wenn ein früheres Ergebnis im selben Zug denselben Zustand gemeldet hat.
### Downloads melden
Wenn ein Klick oder eine Navigation einen Datei-Download startet, melde ihn in `state_changes` beim Ergebnis des Aufrufs, während dessen er stattfand, über Ergebnisse hinweg korreliert durch eine `download_id`, die du vergibst. Downloads laufen asynchron und können sich über mehrere Ergebnisse erstrecken, daher gibt es drei Ereignistypen:
| `type` | Felder | Wann senden |
| -------------------- | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `download_started` | `download_id`, `url` | Beim Ergebnis des Aufrufs, während dessen der Download begann. `url` ist die endgültige URL, von der die Datei ausgeliefert wird, nach Weiterleitungen. |
| `download_completed` | `download_id`, `url`, `path?`, `size_bytes?` | Beim Ergebnis desjenigen späteren Aufrufs, der gerade läuft, wenn der Download abgeschlossen wird. Füge `path` nur bei, wenn ein anderes Tool in derselben Umgebung (zum Beispiel das [Bash-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/bash-tool) oder `file_upload`) die Datei dort lesen kann; andernfalls ist `download_id` die einzige Kennung des Downloads. |
| `download_failed` | `download_id`, `url`, `error?` | Wenn der Download fehlschlägt oder abgebrochen wird, mit dem Grund in `error`, falls der Browser einen liefert. |
Die API rendert jeden Eintrag als eine Textzeile für Claude, in der Reihenfolge der Einträge. Sie fügt die Zeilen nach dem Text des Ergebnisses ein, durch eine Leerzeile getrennt und vor einer etwaigen Tab-Context-Fußzeile. Ergebnisse aller Member-Arten enthalten die Zeilen, auch `zoom`-Ergebnisse und Ergebnisse der Tab-Verwaltung. Ein Ergebnis ohne `text`-Block erhält sie als eigenen Textblock. Jede Zeile nennt `download_id` und `url`, dazu `path` und `size_bytes` (bei `download_completed`) bzw. `error` (bei `download_failed`), sofern du sie sendest. Du musst den Download nicht in deinem eigenen Text beschreiben. Die API setzt `url`, `path` und `error` in doppelte Anführungszeichen und maskiert darin enthaltene doppelte Anführungszeichen und Backslashes. Maskiere diese Werte daher nicht vorab.
Ein Beispiel: Ein Klick auf „Download price list (CSV)" (`ref_8`) im Pricing-Tab startet einen Download. Das Ergebnis des Klicks enthält daher einen `download_started`-Eintrag mit der `download_id` `"dl-1"` und der URL der Datei. Der Download wird abgeschlossen, während ein späterer `screenshot`-Aufruf läuft. Der `content` dieses Ergebnisses enthält daher das Bild, einen Textblock wie `Screenshot captured.` und diesen `browser_state`-Block, der den Abschluss unter derselben `download_id` meldet:
```json
{
"type": "browser_state",
"tabs": [
{ "tab_id": "tab-1", "title": "Documentation", "url": "https://example.com/docs" },
{
"tab_id": "tab-2",
"title": "Pricing",
"url": "https://example.com/pricing",
"active": true
}
],
"state_changes": [
{
"type": "download_completed",
"download_id": "dl-1",
"url": "https://example.com/pricing/price-list.csv",
"path": "/home/user/downloads/price-list.csv",
"size_bytes": 48213
}
]
}
```
Claude sieht `Screenshot captured.`, gefolgt von einer Leerzeile und einer Zeile wie dieser:
```text wrap
Download completed with download_id: dl-1, URL: "https://example.com/pricing/price-list.csv". Saved to "/home/user/downloads/price-list.csv". Size: 48213 bytes.
```
Download-Meldungen folgen diesen Regeln:
* Höchstens ein Eintrag pro `download_id` in einem einzelnen Block, sodass ein Download, der während desselben Aufrufs startet und endet, nur `download_completed` meldet.
* Sende `state_changes` niemals bei einem Ergebnis mit `is_error: true`; melde ein Download-Ereignis, das während eines fehlgeschlagenen Aufrufs auftrat, beim nächsten erfolgreichen Ergebnis.
* `state_changes` ist kein Inventar laufender Downloads; melde jedes Ereignis einmal.
* Jeder Eintrag trägt nur die Felder, die sein `type` deklariert. `size_bytes` ist eine nicht negative Ganzzahl, `download_id` ist nicht leer, und `download_id`, `url`, `path` und `error` sind jeweils höchstens 4.096 Zeichen lang, ohne Steuerzeichen oder Unicode-Zeilen- oder Absatztrennzeichen. Die `url` stammt vom entfernten Server und trägt nach Weiterleitungen oft signierte Query-String-Anmeldedaten. Entferne also Query-Parameter, die du nicht in Claudes Kontext haben möchtest, und bereinige sie, bevor du sie meldest oder in einem Dateisystempfad verwendest.
## Fehler behandeln
Melde einen fehlgeschlagenen Aufruf an Claude als gewöhnliches Fehlerergebnis: `is_error: true`, Textinhalt, der sagt, was schiefging, `toolset_name` zurückgegeben und kein `browser_state`-Block.
### Fehler aus deinem Executor zurückgeben
Formuliere Fehlertext spezifisch, denn Claude liest ihn und passt sich an: `Error: Navigation to https://example.com/status timed out after 30 seconds. The page may be unavailable.` gibt Claude etwas, worauf es reagieren kann, wo ein bloßes `Error: navigation failed` das nicht tut. Weitere häufige Fälle:
```json
{
"type": "tool_result",
"tool_use_id": "toolu_01LeUTyqkhRxBFq1QTG3pkwN",
"toolset_name": "browser",
"is_error": true,
"content": "Error: Navigation refused. Only http and https URLs are allowed."
}
```
```json
{
"type": "tool_result",
"tool_use_id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV",
"toolset_name": "browser",
"is_error": true,
"content": "Error: ref_3 is stale or not found on the current page. Re-read the page to get fresh references."
}
```
```json
{
"type": "tool_result",
"tool_use_id": "toolu_013h2Q55HcNwVyapSpy2s5ZG",
"toolset_name": "browser",
"is_error": true,
"content": "Error: javascript_exec is not enabled in this environment."
}
```
Wenn der `left_click` auf `ref_3` aus [Aktionen bündeln](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#batch-actions) mit dem zuvor gezeigten Fehler wegen veralteter Referenz fehlschlägt, erhalten die `type`- und `key`-Aufrufe danach jeweils dieses Ergebnis:
```json
{
"type": "tool_result",
"tool_use_id": "toolu_01FkP8rTz6uYh2mNq4LsXw7v",
"toolset_name": "browser",
"is_error": true,
"content": "Not executed: an earlier action in this turn failed."
}
```
### Anfragefehler
Die API validiert den Toolset-Eintrag und jeden Member-`tool_use`- und `tool_result`-Block in der Konversation. Wenn einer fehlerhaft ist, gibt die API einen `invalid_request_error` zurück, bevor Claude läuft. In der folgenden Tabelle benennt die linke Spalte, was du gesendet hast.
| Anfrage | Warum sie fehlschlägt und was zu tun ist |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Eine Option oder Kombination, die der Toolset-Eintrag nicht akzeptiert, zum Beispiel ein `name`, `strict: true`, `input_examples`, `defer_loading` am Eintrag selbst, ein `configs`-Schlüssel, der kein Member-Name ist, ein anderes Feld als `enabled` oder `defer_loading` im `configs`-Wert eines Members ([Das Toolset konfigurieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#configure-the-toolset)), aktivierte Member, deren `defer_loading`-Werte sich unterscheiden ([Das Toolset konfigurieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#configure-the-toolset)), ein `configs`, das keinen Member aktiviert lässt, ein Code-Execution-Aufrufer in `allowed_callers`, der veraltete Beta-Header `fine-grained-tool-streaming-2025-05-14` in der Anfrage, ein `tool_choice` vom Typ `tool`, das `browser` oder einen Member benennt, oder ein zweiter Browser-Toolset-Eintrag oder ein anderes Tool namens `browser` | Diese werden bei Client-Toolsets nicht unterstützt. Siehe [Client-Toolsets](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference#client-toolsets) für jede Regel und ihre Alternative. |
| Ein `tool_result`, das einen Member-Aufruf ohne `"toolset_name": "browser"` oder mit einem anderen Wert beantwortet, oder `toolset_name` bei einem Ergebnis, dessen Aufruf kein Member-Aufruf war | Gib `toolset_name` bei Member-Ergebnissen exakt zurück, und nur bei diesen. |
| Ein Member-`tool_use` aus einem früheren Zug ohne passendes `tool_result` | Beantworte jeden Member-Aufruf, einschließlich derer, die du nach einem Fehler nicht ausgeführt hast. |
| Ein anderer Inhaltsblock als `text`, `image` oder `browser_state` in einem Member-Ergebnis | Member-Ergebnisse akzeptieren nur diese drei Blocktypen. |
| Ein `browser_state`-Block, der eine Regel aus [Tabs mit `browser_state` verfolgen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#track-tabs-and-page-state) bricht, zum Beispiel einer bei einem Ergebnis mit `is_error: true` oder bei einem Ergebnis, das keinen Browser-Member-Aufruf beantwortet, mehr als einer in einem Ergebnis, ein nicht leeres `tabs` ohne genau einen `active: true`-Eintrag, eine doppelte `tab_id`, ein leeres `state_changes`-Array, ein `tab_opened`, dessen `tab_id` nicht in `tabs` steht, zwei Zustandsänderungen für eine `download_id` oder ein Zustandsänderungsfeld, das sein `type` nicht deklariert ([Downloads melden](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#report-downloads)), oder ein Feld über seinen Limits | Korrigiere den Block. „Nichts zu melden“ wird durch Weglassen des Blocks oder des `state_changes`-Felds ausgedrückt, niemals durch einen leeren Wert. |
| Ein erfolgreiches `new_tab`-, `switch_tab`-, `close_tab`- oder `list_tabs`-Ergebnis, dessen `content` nicht genau ein `browser_state`-Block ist, oder ein `new_tab`-Ergebnis ohne genau ein `tab_opened`, das zum aktiven Tab passt | Die API rendert diese Ergebnisse aus dem Block und benötigt ihn in genau dieser Form; siehe [Ergebnisse der Tab-Verwaltung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#tab-management-results). |
| Ein `image` in einem Ergebnis über den [Bildgrößenlimits](https://platform.claude.com/docs/de/build-with-claude/vision#evaluate-image-size) deines Modells oder über dem strengeren Limit pro Bild, das gilt, sobald die Anfrage [mehr als 20 Bilder](https://platform.claude.com/docs/de/build-with-claude/vision#request-limits) enthält, wobei Screenshots und `zoom`-Bilder in früheren Ergebnissen mitzählen | Die API skaliert Toolset-Bilder nicht herunter. Verkleinere Screenshots, bevor du sie zurückgibst ([Screenshots an Bildlimits anpassen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions)). |
| Ein `model`, das `browser_toolset_20260801` nicht unterstützt | Siehe [Kompatibilität](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#compatibility) für die unterstützten Modelle. |
## Einschränkungen
* **Plattformverfügbarkeit:** Browser-Nutzung ist auf der Claude API und [Google Cloud](https://platform.claude.com/docs/de/build-with-claude/claude-on-vertex-ai) verfügbar.
* **Nur Streaming der gesamten Eingabe:** Wenn du streamst, kommt das `input` jedes Members als ein vollständiges `input_json_delta` an ([Client-Toolsets](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference#client-toolsets)).
* **Elementreferenzen sind Best-Effort:** Hochdynamische Seiten (virtualisierte Listen, Canvas-gerenderte Oberflächen, Seiten, die beim Scrollen neu rendern) stellen möglicherweise keine stabilen Referenzen bereit, und Claude greift dort auf Screenshots und Koordinatenklicks zurück.
* **`read_console` und `read_network` hängen von deiner Browser-Automatisierung ab:** Sie melden nur, was diese erfassen kann, und nur ab dem Moment, in dem sie sich an einen Tab angehängt hat.
* **Allgemeine Agenten-Einschränkungen gelten:** Latenz, Vision-Genauigkeit und Prompt-Injection-Risiken übertragen sich von Computer Use (siehe die [Einschränkungen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#understand-computer-use-limitations) des Computer-Use-Tools), und dessen Hinweise unter [Modellleistung durch Prompting optimieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#optimize-model-performance-with-prompting), [Screenshot-Verlauf verwalten](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#manage-screenshot-history) und [Best Practices für die Implementierung befolgen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#follow-implementation-best-practices) (Aktionsverzögerungen, Aktionsvalidierung und Logging) gelten auch für Browser-Executors.
## Preise und Datenaufbewahrung
„Browser use“ (Browser-Nutzung) folgt der standardmäßigen [Preisgestaltung für Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview#pricing). Bei der Verwendung des Browser-Use-Tools gilt:
**Overhead der Toolset-Definition:** Die Deklaration von `browser_toolset_20260801` mit seinen Standardmitgliedern fügt einer Anfrage etwa 6.600 Input-Token hinzu (etwa 6.670 bei Claude Sonnet 5 und etwa 6.610 bei den anderen unterstützten Modellen), was die Definitionen der Mitglieds-Tools und den System-Prompt für die Tool-Nutzung abdeckt. Das Aktivieren aller vier optionalen Mitglieder fügt etwa 880 Token hinzu, und das Deaktivieren von Mitgliedern mit `configs` verringert die Anzahl. Die genaue Anzahl für eine Anfrage wird im `usage` der Antwort angegeben, und du kannst sie vorab mit dem [Token-Counting-Endpunkt](https://platform.claude.com/docs/de/build-with-claude/token-counting) abschätzen.
**Zusätzlicher Token-Verbrauch:**
* Screenshot- und Zoom-Bilder, die in Tool-Ergebnissen zurückgegeben werden, abgerechnet als Bild-Input (siehe [Vision-Preisgestaltung](https://platform.claude.com/docs/de/build-with-claude/vision#evaluate-image-size))
* Text-Tool-Ergebnisse, die an Claude zurückgegeben werden, wie z. B. Accessibility-Trees, Seitentext sowie Konsolen- oder Netzwerkeinträge
Wenn du neben Browser use auch das Computer-Use-Tool, das Bash-Tool, das Text-Editor-Tool oder deine eigenen Tools verwendest, haben diese Tools ihre eigenen Token-Kosten, wie auf ihren jeweiligen Seiten dokumentiert.
Die Browser-Sitzung, Downloads und hochgeladene Dateien bleiben in deiner Umgebung; die Screenshots, der Seitentext und der Tab-Zustand, die du zurückgibst, sind Teil deines API-Anfrageinhalts und folgen der Standard-Aufbewahrungsrichtlinie oder deiner ZDR-Vereinbarung, falls du eine hast. Das Browser-Use-Tool ist ZDR-berechtigt; siehe [API und Datenaufbewahrung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention) für Aufbewahrungsfristen und Berechtigung über alle Funktionen hinweg.
## Nächste Schritte
Starte mit dem Treiber eines Partners oder schreibe deinen eigenen in Python oder TypeScript. Das SDK führt die Schleife und die von dir konfigurierten Prüfungen aus.
Gib Claude die Kontrolle über einen vollständigen Desktop, wenn die Aufgabe den Browser verlässt; seine Implementierungshinweise gelten auch für Browser-Executors.
Formatiere `tool_result`-Blöcke, gib Bilder und Fehler zurück und setze die Konversation fort.
Durchsuche Client-Toolsets und alle anderen von Anthropic bereitgestellten Tools mit ihren Versionen und Parametern.