Configurer browser-use avec un navigateur contrôlé

browser-use peut planifier des tâches de navigateur, mais sa boucle d’agent ne choisit pas un exécutable fiable et ne décide pas si une action sensible est sûre. BotBrowser peut fournir un Chromium avec profil pour un flux autorisé ; l’opérateur doit encore sélectionner l’exécutable et le profil, vérifier ce qui a démarré et approuver les actions qui modifient des comptes, de l’argent ou des données. La carte de démarrage de l’automatisation présente le premier parcours général ; cette page traite le passage à browser-use.

Pour browser-use, BotBrowser peut fournir le lancement Chromium explicite et l’argument --bot-profile; il ne fournit ni le framework d’agent ni une politique de tâche et ne garantit pas la classification d’un site.

TL;DR

• Considérez browser-use comme planificateur et contrôleur, pas comme autorité de profil ou de politique.
• Passez un exécutable Chromium explicite et l’argument de profil au lancement Playwright sous-jacent.
• Lisez le processus lancé et une page de fixture contrôlée avant de confier une tâche réelle à l’agent.
• Arrêtez-vous pour les identifiants, achats, suppressions, permissions et envois irréversibles.
• Un lancement correct prouve la configuration, pas le résultat d’un détecteur ou d’une application.

Sommaire

• Séparer planification, lancement et approbation
• Configurer un exécutable et un profil explicites
• Vérifier le processus et le fixture visible
• Utiliser une table pour le passage à l’opérateur
• Fixture d’échec et récupération bornée
• Conclusion pratique

Séparer planification, lancement et approbation

Lorsque l’agent passe par un serveur MCP au lieu de lancer Chromium, le guide sur la propriété du navigateur headless précise quel composant contrôle les arguments de démarrage et quels résultats parviennent à l’agent.

browser-use transforme une tâche en langage naturel en actions de navigateur. Sa documentation et son dépôt public décrivent un framework d’agent basé sur Playwright ; ils n’en font ni un fournisseur de navigateur, ni un émetteur de profils, ni un système d’autorisation. Gardez trois responsables visibles : browser-use planifie, le lanceur possède le processus et le profil, et une personne approuve les étapes sensibles. Le guide Playwright du lancement avec profil décrit le contrat inférieur.

Une tâche terminée signifie seulement que l’agent a atteint une page ou activé un contrôle. Cela ne prouve pas que le bon binaire a démarré, que le profil a été chargé ou qu’un service distant a accepté la session. Ces observations sont distinctes et doivent être vérifiées séparément.

Utilisez une route de staging que vous contrôlez pour le premier essai de browser-use. Un fixture local peut exposer un identifiant de build fixe, un état de consentement et un bouton sans effet ; une page tierce peut changer de politique entre deux essais. Gardez la tâche courte jusqu’à l’accord des contrôles du processus et du fixture.

Configurer un exécutable et un profil explicites

La configuration Python de browser-use finit par atteindre un lancement Playwright. Les noms exacts des constructeurs peuvent changer ; épinglez donc la version et consultez sa référence actuelle. Le contrat reste le même : executable_path désigne le binaire BotBrowser approuvé et le profil est passé comme argument du navigateur, sans navigateur groupé ni script de page.

import asyncio
from browser_use import Agent, Browser, BrowserConfig

async def main():
    browser = Browser(
        config=BrowserConfig(
            headless=True,
            executable_path="/opt/botbrowser/chrome",
            args=["--bot-profile=/srv/profiles/approved.enc"],
        )
    )
    agent = Agent(
        task="Open the owned staging fixture and report its build identifier. Do not sign in or submit anything.",
        browser=browser,
    )
    await agent.run()

asyncio.run(main())

Cet exemple montre la limite, pas une promesse d’API universelle. Vérifiez les options avec la version épinglée. Le profil est un argument de ligne de commande BotBrowser et doit rester dans args, avec un chemin absolu avant la première page. La référence des options CLI BotBrowser précise la syntaxe et les restrictions de niveau.

N’installez pas un paquet qui télécharge silencieusement un autre Chromium avant de supposer que le profil est actif. Désactivez le navigateur groupé ou utilisez le lanceur compatible. Conservez dans un reçu expurgé l’exécutable, l’identifiant de profil, les versions et le runId; n’y mettez jamais cookies, jetons, contenu de profil ou identifiants proxy.

Garder la tâche à distance de la politique de lancement

Le prompt doit décrire la page contrôlée et l’observation sans effet. Il ne doit pas contenir un nouvel exécutable, un secret ou une instruction qui affaiblit une politique. La configuration reste dans le code révisé.

Vérifier le processus et le fixture visible

Faites deux lectures indépendantes. Inspectez le processus créé par Playwright et comparez son chemin et ses arguments avec les valeurs déclarées. Interrogez ensuite un fixture contrôlé pour des valeurs stables et non sensibles. La page ne prouve pas quel processus l’a créée, tandis que le processus ne prouve pas l’état affiché par l’application ; gardez les deux contrôles.

async def verify(page, browser, expected_executable, expected_profile):
    process = browser.playwright_browser.process
    observed_executable = process.args[0] if process and process.args else None
    observed_args = process.args if process else []
    fixture = await page.evaluate("""() => ({
      build: document.querySelector('[data-build]')?.dataset.build ?? null,
      consent: document.querySelector('[data-consent]')?.dataset.consent ?? null,
      userAgent: navigator.userAgent
    })""")
    return {
        "executableMatches": observed_executable == expected_executable,
        "profileArgumentPresent": any(expected_profile in arg for arg in observed_args),
        "fixture": fixture,
    }

Le résultat attendu peut être staging-2026-11-06, un consentement not-requested et un user-agent non vide. Le user-agent est une observation, pas un verdict de détection. Si une comparaison échoue, arrêtez la délégation et classez le problème comme configuration de lancement. L’article sur la gestion des profils sépare l’identifiant du contenu sensible.

{
  "runId": "browser-use-check-20261106-01",
  "declared": {
    "executable": "/opt/botbrowser/chrome",
    "profile": "approved.enc",
    "fixture": "staging-2026-11-06"
  },
  "observed": {
    "executableMatches": true,
    "profileArgumentPresent": true,
    "fixtureBuild": "staging-2026-11-06",
    "consent": "not-requested"
  },
  "firstFailure": null
}

launch_record = {"executable": "/opt/botbrowser/chrome", "profile": "approved.enc", "fixture": "staging-2026-11-06"}
assert launch_record["executable"].startswith("/opt/")

BotBrowser peut fournir un Chromium avec profil pour un lancement Playwright autorisé, mais il ne fournit pas browser-use et ne garantit ni le verdict d’un détecteur ni la réussite d’une tâche.

Comparer une référence avant d’élargir le périmètre

Notez l’exécutable, le profil, la version et le fixture avant d’élargir la tâche. Changez une seule variable et demandez une nouvelle approbation quand le contrat change.

Garder les identifiants hors de la boucle de l’agent

Les identifiants et codes privés passent par un flux de secrets approuvé, jamais par le prompt ou la trace de l’agent.

Utiliser une table pour le passage à l’opérateur

L’agent ne continue que lorsque la configuration déclarée correspond à l’observation et que l’étape suivante est réversible. Une personne doit posséder les identifiants, le consentement, le paiement, la suppression, l’octroi de permission et toute mutation distante incertaine.

Observation	L’agent peut continuer	Action de l’opérateur
Exécutable et profil concordants ; fixture en lecture seule	Lire une page de staging	Vérifier le périmètre
Exécutable différent ou argument absent	Non	Corriger le lancement et rejouer le fixture
Le fixture demande une connexion ou une permission	Non	Fournir identifiant ou consentement par le flux approuvé
Achat, suppression, publication ou envoi imminent	Non	Vérifier les paramètres finaux et approuver une fois
Timeout après une écriture possible	Pas de nouvelle tentative aveugle	Consulter un état idempotent ou passer au responsable

Cette table est une frontière opérationnelle, pas une garantie du modèle. Implémentez la pause avec un callback d’approbation explicite ; une phrase du prompt ne protège pas un compte réel.

Fixture d’échec et récupération bornée

Testez l’arrêt avec un fixture qui omet volontairement la marque de build. L’agent doit signaler son absence puis s’arrêter, plutôt que cliquer jusqu’à l’apparition d’une autre page.

async def read_build(page):
    value = await page.locator("[data-build]").get_attribute("data-build")
    if value is None:
        raise RuntimeError("owned fixture missing data-build; stop delegation")
    return value

Récupérez dans l’ordre : argument absent, problème de lanceur ; marque absente, problème de fixture ; écran de connexion, frontière d’approbation ; timeout après écriture, résultat distant incertain. Redémarrer l’agent dans les quatre cas peut dupliquer une écriture.

FAQ

browser-use garantit-il le résultat d’un détecteur ?

Non. Il coordonne des actions. Un exécutable et un profil contrôlés rendent le lancement reproductible, mais aucun composant ne garantit le verdict d’un détecteur ou d’un site.

L’agent peut-il choisir un profil à l’exécution ?

Pas parmi des fichiers sans restriction. Résolvez un profil approuvé au déploiement, consignez la règle et laissez une personne changer ce choix.

L’agent doit-il envoyer un achat après avoir trouvé le bon article ?

Pas sans point d’approbation explicite. Il peut préparer un panier révisable, tandis qu’une personne confirme destinataire, montant, consentement et envoi final.

Le user-agent visible suffit-il à vérifier le lancement ?

Non. Associez-le à la lecture du processus, à l’argument de profil et à un fixture fixe.

Conclusion pratique

Configurez browser-use comme un contrat de lancement révisé, un fixture contrôlé et une frontière d’approbation humaine. Démarrez l’exécutable explicite avec le profil approuvé, comparez processus et fixture, puis arrêtez-vous à toute différence ou action sensible. Le parcours devient auditable sans promettre contournement, taux de réussite ou décision distante.

Sources

• Dépôt browser-use
• Documentation browser-use
• API BrowserType Playwright Python
• Configuration Playwright BotBrowser
• Options CLI BotBrowser
• Cadre de gestion des risques IA du NIST