---
title: "Browser Use mit Proxy: KI-Browser-Agenten einrichten"
description: "Browser Use lässt ein LLM per Python einen echten Browser steuern: Agent mit Proxy und Passwort einrichten, Ausgangs-IP prüfen und erlaubte Websites begrenzen."
url: https://proxynet.io/de/blog/browser-use-proxy
date: 2026-10-05
author: "Acar Diveroli"
category: "Integration, KI"
lang: de
---
# Browser Use mit Proxy: KI-Browser-Agenten einrichten
Ihr Browser-Use-Agent gibt vom Laptop aus problemlos eine Testbestellung in Ihrem Staging-Shop auf. Auf einen Cloud-Server verschoben, öffnet dieselbe Aufgabe die Website von einer Datacenter-Adresse in einem anderen Land: Der Shop zeigt eine andere Währung, und Ihre Staging-Firewall, die nur bekannte IPs hereinlässt, weist den Agenten ab. Sie tragen einen Proxy als `http://user:pass@pr.proxynet.io:8000` ein, und nun scheitert jede Seite mit `net::ERR_NO_SUPPORTED_PROXIES`.
Dieser Leitfaden behandelt, wie Browser Use funktioniert, die Installation, einen Proxy mit Benutzername und Passwort, die Prüfung der Ausgangs-IP, Sticky- und rotierende Sitzungen, Domain-Grenzen, Geheimnisse und einen Freigabeschritt durch einen Menschen. Alle Skripte haben wir mit browser-use 0.13.10 und Python 3.13 über einen lokalen Test-Proxy ausgeführt, der ein Passwort verlangt. Da auf dem Testrechner kein API-Schlüssel für ein LLM vorhanden war, lieferte ein vorab geschriebenes Testskript die Antworten des Modells; Browser, Proxy, Domain-Filter und das Maskieren der Geheimnisse liefen dagegen echt.
> **Hinweis: Kurzantwort**
>
> Browser Use ist eine Open-Source-Bibliothek für Python (MIT-Lizenz), mit der ein Sprachmodell einen Chromium-Browser steuert: Das Modell liest die Seite, wählt Aktionen wie Klicken oder Tippen, und die Bibliothek führt sie aus. Installiert wird sie mit `uv pip install browser-use`, Chromium holen Sie mit `uvx browser-use install`. Der Proxy gehört zum Browser: `Browser(proxy=ProxySettings(server="http://pr.proxynet.io:8000", username="user", password="pass"))`. Zugangsdaten in der Serveradresse scheitern, ebenso SOCKS5 mit Passwort. Nutzen Sie für mehrstufige Aufgaben eine Sticky-Sitzung und Platzhalter in `sensitive_data`, damit Passwörter nie beim Modell ankommen.
## Was ist Browser Use?
Browser Use ist eine Python-Bibliothek, die aus einem Sprachmodell einen Browser-Agenten macht. Sie beschreiben die Aufgabe in einfachen Worten, und das Modell entscheidet über Klicks, Eingaben und Scrollen. Das [GitHub-Repository](https://github.com/browser-use/browser-use) beschreibt das Projekt als „Agents that use the browser“ (Agenten, die den Browser benutzen); es steht unter der MIT-Lizenz, und die aktuelle Version auf [PyPI](https://pypi.org/project/browser-use/) ist heute 0.13.10, veröffentlicht am 4. September 2026, für Python 3.11 oder neuer.
Version 0.13.10 spricht Chromium direkt über das Chrome DevTools Protocol (CDP) an; Playwright gehört nicht zu den Abhängigkeiten. Das Modell kann von OpenAI, Anthropic, Google, einem lokalen Ollama-Server oder aus den eigenen gehosteten Modellen von Browser Use kommen. Browser Use Cloud, ein separater kostenpflichtiger Dienst mit gehosteten Browsern, ist nicht Teil dieses Leitfadens.
Wie ein Agent allgemein plant und Tools nutzt, erklärt [Wie funktionieren KI-Agenten?](/de/blog/how-ai-agents-work); Browser mit eingebautem Agenten beschreibt [Was ist ein KI-Browser?](/de/blog/what-is-an-ai-browser).
## Wie arbeitet ein Browser-Use-Agent?
Ein einzelnes `agent.run()` durchläuft diese Schritte:
1. **Der Browser startet** mit einem frischen temporären Profil. Der Proxy wird Chromium als Startparameter übergeben.
2. **Eine URL in der Aufgabe wird direkt geöffnet**, ohne Modellaufruf.
3. **Die Seite wird in Text umgewandelt.** Jedes Element, das der Agent nutzen kann, bekommt eine Nummer, und der sichtbare Text kommt dazu. Mit `use_vision=True` (Standard) wird ein Screenshot angehängt.
4. **Das Modell antwortet in JSON:** eine Bewertung des letzten Schritts, ein kurzes Gedächtnis, das nächste Ziel und bis zu fünf Aktionen wie `navigate`, `click`, `input`, `scroll`, `extract` oder `done`.
5. **Die Bibliothek führt die Aktionen aus,** prüft jede neue URL gegen Ihre Domain-Regeln und setzt Geheimnisse dort ein, wo das Modell einen Platzhalter geschrieben hat.
6. **Die Schleife wiederholt sich,** bis das Modell `done` aufruft oder `max_steps` aufgebraucht ist.
Auf einer Übungs-Buchhandlung enthielt der Browserzustand, den unser Testmodell erhielt, Zeilen wie diese:
```text
[587]
It's Only the Himalayas
£45.17
[597]
In stock
[604]
Add to basket
```
Um dieses Buch in den Warenkorb zu legen, würde das Modell `{"click": {"index": 604}}` antworten. Weil die Seite als Text ankommt, funktioniert auch `use_vision=False`, und Screenshots sensibler Seiten gelangen nicht zum Modellanbieter.
## Wie installieren Sie Browser Use?
Der offizielle Schnellstart nutzt uv:
```bash
pip install uv
uv venv --python 3.12
source .venv/bin/activate # Windows: .venv\Scripts\activate
uv pip install browser-use
uvx browser-use install # lädt Chromium herunter
```
Wir haben mit einfachem `pip install browser-use==0.13.10` in eine virtuelle Umgebung mit Python 3.13 installiert, was ebenfalls funktionierte. Legen Sie die Schlüssel dann in eine `.env`-Datei neben Ihrem Skript:
```bash
OPENAI_API_KEY=...
PROXY_SERVER=http://pr.proxynet.io:8000
PROXY_USERNAME=user
PROXY_PASSWORD=pass
ANONYMIZED_TELEMETRY=false
```
Die letzte Zeile ist wichtig. Browser Use sendet standardmäßig Nutzungstelemetrie, und laut seiner [Telemetrie-Seite](https://docs.browser-use.com/open-source/development/monitoring/telemetry) kann sie Aufgabenbeschreibungen, besuchte URLs, Aktionsverläufe und Endergebnisse enthalten. Wenn Ihre Aufgaben Kunden oder interne Websites nennen, schalten Sie sie ab.
Zwei Dinge haben uns auf dem Windows-Testrechner überrascht. Ohne `executable_path` wählte Browser Use das installierte Google Chrome, allerdings mit einem neuen temporären Profil statt Ihres Alltagsprofils. Beim ersten Start lud es außerdem drei Erweiterungen, darunter einen Werbeblocker, direkt aus dem Chrome Web Store herunter, und zwar am Proxy vorbei; `enable_default_extensions=False` schaltet sie ab.
## Wie lassen Sie einen Agenten über einen Proxy laufen?
Der Proxy ist eine Einstellung des `Browser`, und der Agent bekommt diesen Browser. Dieses Skript öffnet eine Kategorieseite und liest drei Bücher aus; der Verkehr geht nur über den Proxy hinaus und nur zu einer Domain:
```python
"""Einen Browser-Use-Agenten über einen Proxy mit Passwort betreiben, beschränkt auf eine Website."""
import asyncio
import os
from dotenv import load_dotenv
load_dotenv() # liest OPENAI_API_KEY, PROXY_* und ANONYMIZED_TELEMETRY aus .env
from browser_use import Agent, Browser, ChatOpenAI
from browser_use.browser import ProxySettings
browser = Browser(
headless=True,
proxy=ProxySettings(
server=os.environ["PROXY_SERVER"], # http://pr.proxynet.io:8000
username=os.environ["PROXY_USERNAME"],
password=os.environ["PROXY_PASSWORD"],
),
allowed_domains=["books.toscrape.com"],
enable_default_extensions=False,
)
agent = Agent(
task=(
"https://books.toscrape.com/catalogue/category/books/travel_2/index.html öffnen "
"und Titel und Preis der ersten drei Bücher auflisten."
),
llm=ChatOpenAI(model="gpt-4.1-mini"),
browser=browser,
use_vision=False,
)
async def main():
history = await agent.run(max_steps=10)
print("result:", history.final_result())
print("pages: ", [u for u in history.urls() if u])
print("steps: ", history.number_of_steps())
asyncio.run(main())
```
`ProxySettings` wird aus `browser_use.browser` importiert, nicht aus dem Paket der obersten Ebene. Die [Seite mit den Browser-Parametern](https://docs.browser-use.com/open-source/customize/browser/all-parameters) nennt vier Felder:
| Feld | Was es aufnimmt |
|---|---|
| `server` | `http://host:port` oder `socks5://host:port`, ohne Zugangsdaten |
| `username` | Proxy-Benutzername, zum Beispiel der aus dem Endpoint-Generator |
| `password` | Proxy-Passwort |
| `bypass` | Hosts, die am Proxy vorbeigehen, durch Kommas getrennt |
Intern startet Browser Use Chromium mit `--proxy-server` und beantwortet die `407`-Aufforderung des Proxys selbst über CDP. Unser Test-Proxy hat genau das für die Buchseite protokolliert (gekürzt, ohne Zeitstempel):
```text
407 CONNECT books.toscrape.com:443 (no credentials)
200 CONNECT books.toscrape.com:443 user=user
```
Benutzername und Passwort des Proxys tauchten in nichts auf, was das Modell erhielt.
## Warum scheitert user:pass in der Proxy-URL?
Weil Chromium Zugangsdaten ignoriert, die in seine Proxy-Einstellung geschrieben sind. Laut der [Proxy-Dokumentation von Chromium](https://chromium.googlesource.com/chromium/src/+/HEAD/net/docs/proxy.md) verwendet Chrome keine Zugangsdaten, die in die Proxy-Einstellungen eingebettet sind. Mit `server="http://user:pass@…"` und ohne separate Felder endete in unserem Test jede Navigation mit `net::ERR_NO_SUPPORTED_PROXIES`. Tragen Sie die Zugangsdaten in `username` und `password` ein.
Bei SOCKS5 gilt eine andere Grenze: Chromium unterstützt für SOCKS5 überhaupt keine Authentifizierungsmethode. Unser SOCKS5-Testserver sah, dass der Browser nur „no authentication“ (keine Authentifizierung) anbot, und die Seite scheiterte mit `ERR_SOCKS_CONNECTION_FAILED`. Tragen Sie für SOCKS5 die IP Ihres Servers im Panel in die IP-Whitelist ein (bis zu 10 Adressen) und nutzen Sie ohne Benutzernamen den SOCKS5-Port, den der Endpoint-Generator anzeigt. Die DNS-Auflösung erfolgt dann auf der Proxy-Seite. Die beiden Anmeldemethoden vergleicht [Proxy-Authentifizierung: User:Pass oder IP-Whitelist](/de/blog/proxy-authentication-methods), die Protokolle [SOCKS und HTTP Proxy im Vergleich](/de/blog/socks-vs-http-proxy).
## Wie prüfen Sie die Ausgangs-IP des Agenten?
Prüfen Sie sie vor der ersten echten Aufgabe, ohne Modell in der Schleife. Dieses Skript nutzt dieselben `ProxySettings`, öffnet eine IP-Echo-Seite und gibt aus, was die Website gesehen hat:
```python
"""Vor jedem Agentenlauf eine IP-Echo-Seite über den Proxy öffnen."""
import asyncio
import os
from browser_use import Browser
from browser_use.browser import ProxySettings
async def main():
browser = Browser(
headless=True,
proxy=ProxySettings(
server=os.environ["PROXY_SERVER"],
username=os.environ["PROXY_USERNAME"],
password=os.environ["PROXY_PASSWORD"],
),
)
await browser.start()
try:
page = await browser.new_page("https://httpbin.org/ip")
await asyncio.sleep(2) # Seite laden lassen
print(await page.evaluate("() => document.body.innerText"))
finally:
await browser.kill()
asyncio.run(main())
```
Es gibt das JSON von httpbin mit einem Feld `origin` aus. Über einen Proxynet-Endpunkt ist das die Ausgangs-IP, nicht Ihre eigene. Führen Sie es zweimal aus: Ein rotierender Benutzername kann zwei verschiedene Adressen zeigen, ein Sticky-Benutzername beide Male dieselbe.
Unser Proxy-Log zeigte außerdem die eigenen Anfragen von Chrome an Google-Dienste und den Abruf des Browser-Use-Logos auf der leeren Startseite; wenn Sie Proxy-Traffic pro GB bezahlen, zählen auch diese mit.
## Rotierend oder Sticky: Welche Sitzung braucht ein Agent?
Der Proxy gehört zum Browser, deshalb geht jeder Schritt einer Aufgabe über dieselbe Proxy-Adresse hinaus. Was sich ändert, ist die Ausgangs-IP hinter dieser Adresse.
| Aufgabe | Sitzung | Warum |
|---|---|---|
| Anmelden und dann auf mehreren Seiten handeln | Sticky, 10-30 Minuten | Viele Websites binden eine Sitzung an eine IP; eine neue Adresse mitten in der Aufgabe kann eine neue Anmeldung bedeuten |
| Pro Lauf eine unabhängige Seite lesen | Rotierend | Jeder Lauf kann einen neuen Ausgang bekommen; nichts wird übernommen |
| Mehrere Agenten parallel | Ein `Browser` pro Agent | Jeder Browser hat eigene Proxy-Einstellungen und eine eigene Sitzung |
| Eine Adresse, die Ihre eigenen Systeme auf eine Positivliste setzen | Statischer ISP-Proxy | Die IP bleibt über Tage gleich |
Bei Proxynet wählen Sie im Endpoint-Generator rotierend oder Sticky, Land und Stadt, mit einer Sticky-Dauer von 1 bis 60 Minuten; der erzeugte Benutzername enthält diese Auswahl bereits, fügen Sie ihn also unverändert in `PROXY_USERNAME` ein. Wählen Sie eine Sticky-Dauer, die etwas länger ist als Ihre längste Aufgabe. Passende Produkte: [Sticky-Proxy](https://proxynet.io/de/sticky-proxy), [Rotierender Proxy](https://proxynet.io/de/rotating-proxy), [ISP-Proxy](https://proxynet.io/de/static-isp-residential-proxy) sowie [Residential-Proxy](https://proxynet.io/de/residential-proxy), wenn eine Prüfung einen privaten Internetanschluss in einem bestimmten Land braucht. Wie Rotation funktioniert, erklärt [Was ist IP-Rotation und wie funktioniert sie?](/de/blog/ip-rotation-explained).
## Wie begrenzen Sie, wohin der Agent gehen kann?
`allowed_domains` nimmt eine Liste von Mustern: `example.com`, `*.example.com` für Subdomains, `http*://example.com` für beide Schemata. Wildcards in der Top-Level-Domain werden abgelehnt. `prohibited_domains` wirkt umgekehrt; sind beide gesetzt, gewinnt die Positivliste.
Wir haben nur unseren lokalen Shop erlaubt und das Testmodell zwei Wege nach draußen versuchen lassen. Ein direktes `navigate` zu einem anderen Host gab dem Modell Folgendes zurück, mit `about:blank` als aktueller Seite:
```text
Navigation failed: Navigation to http://partner.test:28140/ blocked by security policy
```
Ein Link im Shop, der auf denselben Host weiterleitete, endete ebenfalls auf `about:blank`, und das Modell bekam den Text dieser Seite nie zu sehen. Das Log der Testseite zeigte aber, dass der Browser beide Seiten außerhalb der Liste angefragt hatte, bevor die Prüfung sie ersetzte, und ein Bild vom nicht erlaubten Host lud auf einer erlaubten Seite ganz normal. In 0.13.10 steuert der Filter, was der Agent liest und womit er arbeitet, nicht aber, was der Browser sendet.
Für eine echte Grenze beschränken Sie den ausgehenden Verkehr außerhalb des Agenten: eine Firewall oder eine Positivliste auf der Proxy-Seite, ein eigener Container oder ein eigenes Benutzerkonto und kein Zugriff auf interne Adressen. Playwright MCP hat bei seinen Origin-Flags denselben Vorbehalt, wie [Was ist Playwright MCP?](/de/blog/playwright-mcp) zeigt. Das übergeordnete Muster beschreibt [Sicherer Webzugriff für LLMs](/de/blog/llm-safe-web-access).
## Wie halten Sie Zugangsdaten vom Modell fern?
Schreiben Sie nie ein Passwort in die Aufgabe. Die Aufgabe geht bei jedem Schritt an den Modellanbieter und, wenn Sie sie nicht abschalten, in die Telemetrie. Browser Use hat dafür einen Platzhaltermechanismus, `sensitive_data`: Sie übergeben die echten Werte im Code, das Modell sieht nur Namen wie `x_user` und `x_pass`, und die Bibliothek tippt den echten Wert ins Feld, nachdem das Modell geantwortet hat.
In unserem Test lautete die Aktion des Modells `x_pass`, das Log gab „Typed “ aus, und als die Seite den Benutzernamen wieder anzeigte, erhielt das Modell `Signed in as x_user`. Die echten Werte tauchten in keiner Modelleingabe auf. Drei Gewohnheiten runden das ab:
- **Binden Sie Geheimnisse an eine Domain**, damit ein Platzhalter nur auf der Website gefüllt wird, zu der er gehört.
- **Setzen Sie `use_vision=False`** auf Seiten, auf denen ein Screenshot den Wert zeigen könnte.
- **Geben Sie dem Agenten nicht Ihr Chrome-Alltagsprofil** (`Browser.from_system_chrome()`), wenn er fremde Seiten liest: Jede angemeldete Sitzung darin wird für ihn erreichbar.
## Wie fügen Sie einen Freigabeschritt durch einen Menschen hinzu?
Indirekte Prompt Injection bedeutet Text auf einer Seite, den das Modell als Anweisung auffasst. Der [Eintrag LLM01 von OWASP](https://genai.owasp.org/llmrisk/llm01-prompt-injection/) nennt eine menschliche Freigabe für risikoreiche Aktionen unter den Abwehrmaßnahmen. Browser Use ruft `register_new_step_callback` auf, nachdem das Modell seine Aktionen gewählt hat und bevor sie laufen; der Callback kann den Agenten also stoppen:
```python
"""Ein Browser-Use-Agent mit Positivliste, Platzhaltern für Geheimnisse und menschlicher Freigabe."""
import asyncio
import os
from dotenv import load_dotenv
load_dotenv()
from browser_use import Agent, Browser, ChatOpenAI
from browser_use.browser import ProxySettings
SITE = "https://shop.example.com"
READ_ONLY = {"navigate", "scroll", "find_text", "extract", "screenshot", "go_back", "wait", "done"}
browser = Browser(
headless=True,
proxy=ProxySettings(
server=os.environ["PROXY_SERVER"],
username=os.environ["PROXY_USERNAME"],
password=os.environ["PROXY_PASSWORD"],
),
allowed_domains=["shop.example.com"],
enable_default_extensions=False,
)
def approve(browser_state, model_output, step):
"""Läuft, nachdem das Modell seine Aktionen gewählt hat, und bevor sie ausgeführt werden."""
planned = [action.model_dump(exclude_none=True) for action in model_output.action]
if all(next(iter(a)) in READ_ONLY for a in planned):
return
print(f"Step {step} wants to run: {planned}")
if input("Allow? [y/N] ").strip().lower() != "y":
agent.stop()
agent = Agent(
task=f"Auf {SITE}/login mit dem Benutzernamen x_user und dem Passwort x_pass anmelden, dann das Partnerangebot öffnen.",
llm=ChatOpenAI(model="gpt-4.1-mini"),
browser=browser,
sensitive_data={"http*://shop.example.com": {"x_user": os.environ["SHOP_USER"], "x_pass": os.environ["SHOP_PASS"]}},
use_vision=False,
register_new_step_callback=approve,
)
async def main():
history = await agent.run(max_steps=8)
print("done: ", history.is_done())
print("errors:", [e for e in history.errors() if e])
asyncio.run(main())
```
Wir haben das Skript mit geänderter Domain gegen unseren lokalen Shop laufen lassen. Der Anmeldeschritt fragte zuerst nach; nach „y“ tippte der Agent beide Werte ein und klickte. Ein späterer Klick fragte erneut, und nach „n“ meldete das Log „Agent stopping“, der Klick wurde nie ausgeführt, und `is_done()` gab `False` zurück. Jede Aktion außerhalb der Nur-Lese-Menge, auch das Tippen, wartet jetzt auf einen Menschen.
## Browser Use oder Playwright MCP?
Beide lassen ein Modell einen Browser benutzen; sie unterscheiden sich darin, wer die Schleife ausführt.
| | Browser Use | Playwright MCP |
|---|---|---|
| Wer die Agentenschleife ausführt | Die Bibliothek, in Ihrem Python-Code | Der Assistent, den Sie bereits nutzen (Claude Code, Cursor) |
| Proxy mit Passwort | Felder von `ProxySettings` | `launchOptions.proxy` in einer Konfigurationsdatei |
| Domain-Grenze | `allowed_domains` | `--allowed-origins` |
| Geeignet für | Agenten in Ihrem eigenen Dienst | Spontane Arbeit aus einem Coding-Assistenten |
Einrichtung und Flags von Playwright MCP beschreibt [Was ist Playwright MCP?](/de/blog/playwright-mcp).
## Anwendungsfälle
- **Lokalisierungsprüfungen auf Ihrer eigenen Website:** welche Sprache, Währung und welchen Cookie-Hinweis ein Besucher aus einem bestimmten Land bekommt ([Lokalisierung](/de/localization)).
- **Exploratives Testen Ihrer eigenen App:** einen Registrierungs- oder Checkout-Ablauf auf Staging von verschiedenen Standorten aus durchgehen ([App-Tests](/de/app-testing)).
- **Einzelne Abrufe von einer JavaScript-Seite:** ein paar Werte von einer öffentlichen Seite, die im Browser gerendert wird ([statische und dynamische Seiten](/de/blog/static-vs-dynamic-pages)). Für regelmäßige Aufgaben ist ein einfaches Skript günstiger ([Playwright mit Proxy](/de/blog/playwright-proxy)).
- **Sauberer Text für ein Modell statt eines Browsers:** Wenn der Agent nur lesen muss, hilft [Was ist Crawl4AI?](/de/blog/crawl4ai-proxy) weiter.
Ein Agent, der für Sie surft, erzeugt trotzdem automatisierten Verkehr. Browser Use 0.13.10 liest keine robots.txt (wir haben im Paket keinen Code dafür gefunden); lesen Sie daher die [robots.txt](/de/blog/robots-txt) und die Nutzungsbedingungen der Website selbst, nutzen Sie eine offizielle API, wo es eine gibt, bleiben Sie bei wenigen Seiten in menschlichem Tempo und hören Sie auf, wenn eine Website Nein sagt. Warum Websites automatisierte Besucher erkennen, erklärt [Warum werden KI-Shopping-Agenten auf Websites blockiert?](/de/blog/ai-shopping-agents-blocked). Die für Browser Use Cloud beworbenen Stealth- und CAPTCHA-Funktionen behandelt dieser Leitfaden nicht, und wir empfehlen sie nicht.
## Häufige Fehler
| Was Sie sehen | Warum | Was zu tun ist |
|---|---|---|
| `net::ERR_NO_SUPPORTED_PROXIES` | Zugangsdaten in `server` geschrieben | In `username` und `password` verschieben |
| `net::ERR_TOO_MANY_RETRIES` | Falscher Proxy-Benutzername oder falsches Passwort; der Proxy antwortet immer wieder mit `407` | Zugangsdaten erneut aus dem Panel kopieren |
| `net::ERR_PROXY_CONNECTION_FAILED` | Falscher Host oder Port, oder ausgehender Verkehr blockiert | Dieselbe Adresse mit cURL testen |
| `ERR_SOCKS_CONNECTION_FAILED` | `socks5://` mit Passwort | Den HTTP-Endpunkt nutzen oder SOCKS5 mit IP-Whitelist |
| `blocked by security policy` | Die URL liegt außerhalb von `allowed_domains` | Die Domain hinzufügen oder gesperrt lassen |
| Der Agent meldet sich mittendrin erneut an | Ein rotierender Ausgang hat die IP während der Aufgabe gewechselt | Eine Sticky-Sitzung nutzen |
Zwei Gewohnheiten machen ohne Fehlermeldung Ärger: `allowed_domains` als Firewall zu behandeln und eine Version ohne feste Versionsnummer zu betreiben. Die API hat sich zwischen Releases geändert; legen Sie also die getestete Version fest (`browser-use==0.13.10`) und lesen Sie vor einem Upgrade die Release Notes.
## Entscheidungshilfe
| Bedarf | Empfehlung |
|---|---|
| Ein erster Agentenlauf über einen Proxy | `ProxySettings` mit HTTP-Endpunkt, Benutzername und Passwort; danach das IP-Echo-Skript |
| Eine mehrstufige Aufgabe mit Anmeldung | Sticky-Sitzung, länger als die Aufgabe |
| Unabhängige Läufe mit je einer Seite | Rotierende Sitzung |
| Den Agenten auf einer Website halten | `allowed_domains` plus eine Positivliste für ausgehenden Verkehr außerhalb des Agenten |
| Aktionen, die etwas verändern | Ein Freigabe-Callback, der `agent.stop()` aufrufen kann |
## Häufige Fragen
### Ist Browser Use kostenlos?
Die Bibliothek ist unter der MIT-Lizenz kostenlos. Sie bezahlen die Modellaufrufe, mindestens einen pro Schritt, und den Proxy-Traffic. Browser Use Cloud und die gehosteten Modelle werden separat abgerechnet.
### Nutzt Browser Use noch Playwright?
Nicht zur Steuerung des Browsers. Version 0.13.10 steuert Chromium über das Chrome DevTools Protocol; der Installationsbefehl nutzt den Downloader von Playwright für Chromium, und gespeicherte Anmeldezustände verwenden das Dateiformat von Playwright.
### Kann ich ein lokales Modell statt einer API nutzen?
Die Seite zu den unterstützten Modellen zeigt `ChatOllama(model="llama3.1:8b")` für einen lokalen Ollama-Server. Ein lokales Modell haben wir nicht getestet.
### Können zwei Agenten gleichzeitig verschiedene Länder nutzen?
Ja, mit zwei `Browser`-Objekten, jedes mit eigenen `ProxySettings`. Ein Browser hat einen einzigen Proxy für alle seine Tabs.
### Beachtet Browser Use die robots.txt?
Nicht von sich aus; Version 0.13.10 hat keine Prüfung der robots.txt. Lesen Sie die Datei, bevor Sie dem Agenten eine Website geben.
### Verhindert ein Proxy, dass Websites meinen Agenten blockieren?
Nein. Ein Proxy ändert die Adresse, von der eine Anfrage kommt; Verhalten und Tempo des Browsers bleiben gleich. Ein langsames Tempo, erlaubte Seiten und die offizielle API sind der dauerhafte Weg.
## Fazit
Browser Use gibt einem Sprachmodell einen echten Chromium-Browser und führt die Agentenschleife in Ihrem eigenen Python-Code aus. Setzen Sie den Proxy mit `ProxySettings` und getrennten Feldern `username` und `password` am Browser; Zugangsdaten in der URL und SOCKS5 mit Passwort scheitern in Chromium beide. Prüfen Sie die Ausgangs-IP vor der ersten Aufgabe, nutzen Sie für alles mit Anmeldung eine Sticky-Sitzung und behandeln Sie `allowed_domains` als Filter für den Agenten, nicht als Netzwerkgrenze. Halten Sie Geheimnisse in `sensitive_data`, schalten Sie die Telemetrie ab und lassen Sie Aktionen, die etwas verändern, von einem Menschen freigeben. Passende Ausgänge für Ihren Agenten finden Sie bei unseren [Proxy-Diensten](/de/proxy).