Production Integrations

---
name: production-integrations
description: "Deploy and integrate Browser Use with sandbox execution, Browser
  Use Cloud, MCP, hosted skills, profile sync, observability, telemetry, and
  external app integrations. Use for production deployment prompts, cloud
  profiles/proxies, live session monitoring, MCP server/client setup, cloud
  skill execution, Slack/Discord/email app patterns, and monitoring/telemetry."
disable-model-invocation: true
metadata:
  disco-role: operating
license: MIT
---

# Production Integrations

Use this sub-skill when the user wants Browser Use running in production or wired into another product, service, or agent platform. Keep advice safe by default: use environment variables for secrets, constrain domains when secrets are present, prefer cloud profiles for authentication, and validate every external service dependency before launching long-running tasks.

## Quick Routing

| User need | Read |
| --- | --- |
| `@sandbox`, cloud browser execution, profile sync, Cloud REST/API flows | `references/cloud-and-sandbox.md` |
| MCP server/client setup, hosted skills, cloud skill parameter/cookie validation | `references/mcp-and-skills.md` |
| Slack, Discord, email/2FA, app webhooks, monitoring, telemetry opt-out | `references/integrations-and-monitoring.md` |
| Production failure triage and recovery checklists | `references/troubleshooting.md` |

## Boundaries

- For Python `Agent(...)`, run loops, history, callbacks, initial actions, or task prompt design, route to `../agent-programming/SKILL.md`.
- For `Browser(...)`, `BrowserSession`, `BrowserProfile`, local Chrome, CDP, proxy, download, HAR, recording, or domain/session parameters, route to `../browser-control/SKILL.md`.
- For custom `Tools`, `ActionResult`, parameter injection, file tools, sensitive data, and action security guardrails, route to `../tools-and-actions/SKILL.md`.
- For `ChatBrowserUse`, provider credentials, structured output schemas, cost calculation, or fallback model selection, route to `../llm-and-output/SKILL.md`.
- For persistent terminal sessions, `browser-use`/`bu` CLI commands, `--mcp` help, doctor/setup/init, and CLI cloud commands, route to `../cli-and-sessions/SKILL.md`.

## Production Defaults

- Recommend `ChatBrowserUse()` for Browser Use automation unless the user has already selected another model; do not replace user-specified model names.
- Require `BROWSER_USE_API_KEY` for Browser Use Cloud, `@sandbox`, cloud skills, profile sync, and cloud MCP.
- Use hosted cloud browsers for production when the user wants speed, captcha resistance, geo proxies, live streaming, or avoiding local Chromium setup.
- Use `Browser(use_cloud=True)` for Python workflows that need a hosted browser but still run locally; use `@sandbox` when the whole browser automation function should execute in Browser Use managed infrastructure.
- Use cloud profiles for authenticated production workflows instead of embedding passwords in prompts.
- With secrets, add `allowed_domains` or equivalent domain restrictions in the owning Browser/Cloud configuration.
- Keep API keys, app tokens, signing secrets, OAuth client files, and cookies out of code snippets, logs, final output, and committed files.

## Minimal Cloud Browser Pattern

Use this when the app code stays local but the browser should run on Browser Use Cloud:

```python
import asyncio
from browser_use import Agent, Browser, ChatBrowserUse

async def main():
    browser = Browser(use_cloud=True)
    agent = Agent(
        task="Check the current page title and summarize it.",
        browser=browser,
        llm=ChatBrowserUse(),
    )
    history = await agent.run(max_steps=10)
    print(history.final_result())

asyncio.run(main())
```

Validation before running:

```bash
python - <<'PY'
import os
from browser_use import Agent, Browser, ChatBrowserUse, sandbox
print('browser-use imports ok')
print('BROWSER_USE_API_KEY set:', bool(os.getenv('BROWSER_USE_API_KEY')))
PY
```

If the task also needs low-level `Browser` parameters such as `cdp_url`, `allowed_domains`, `record_video_dir`, or proxy objects, read `../browser-control/SKILL.md`.

## Minimal `@sandbox` Pattern

Use this when the user wants the function itself deployed to managed infrastructure with live browser view callbacks:

```python
import asyncio
from browser_use import Agent, Browser, ChatBrowserUse, sandbox

@sandbox(log_level="INFO")
async def run_task(browser: Browser, task: str) -> str | None:
    agent = Agent(task=task, browser=browser, llm=ChatBrowserUse())
    history = await agent.run(max_steps=20)
    return history.final_result()

asyncio.run(run_task("Find the top Hacker News story title."))
```

Operational notes:

- The decorated function must accept injected `browser` as its first argument and the caller should not pass it.
- Configure `cloud_profile_id` for authenticated sessions, `cloud_proxy_country_code` for geo/captcha needs, and `cloud_timeout` to cap session runtime.
- Use callbacks such as `on_browser_created`, `on_log`, `on_result`, and `on_error` when the host app needs live URL, progress logs, or failure alerts.
- `@sandbox` serializes the function and captured inputs for remote execution; keep captured objects small and serializable.

## Cloud Task REST Pattern

Use direct REST when a service wants task-in/result-out cloud execution without embedding the Python library:

```bash
curl -X POST https://api.browser-use.com/api/v2/tasks \
  -H "X-Browser-Use-API-Key: $BROWSER_USE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"task":"Search for the top Hacker News post and return title and URL."}'
```

Then fetch the returned session to watch live execution:

```bash
curl "https://api.browser-use.com/api/v2/sessions/$SESSION_ID" \
  -H "X-Browser-Use-API-Key: $BROWSER_USE_API_KEY"
```

Stop a session when it is no longer needed:

```bash
curl -X PATCH "https://api.browser-use.com/api/v2/sessions/$SESSION_ID" \
  -H "X-Browser-Use-API-Key: $BROWSER_USE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"action":"stop"}'
```

## Authentication and Profiles

- For cloud task authentication, prefer Browser Use profile sync: `export BROWSER_USE_API_KEY=... && curl -fsSL https://browser-use.com/profile.sh | sh`.
- Store the returned cloud profile id in a secret manager or deployment variable, then pass it as `cloud_profile_id` or Cloud API `profile_id`.
- If a user asks how to handle production login, recommend profile sync first, then domain-restricted secrets or custom tools only when profile sync is impossible.
- Do not tell future agents to read original repo examples for profile setup; use `references/cloud-and-sandbox.md`.

## MCP and Hosted Skills

- Local MCP server exposes Browser Use automation to MCP clients via stdio; details live in `references/mcp-and-skills.md`.
- Cloud MCP exposes Browser Use hosted tools over HTTP and requires the Browser Use API key header.
- `MCPClient` can register external MCP tools into a Browser Use `Tools` registry; if the tool is domain/file/security-sensitive, read `../tools-and-actions/SKILL.md`.
- Cloud `SkillService` fetches and executes hosted skills and validates inputs with Pydantic; missing cookies are explicit failures to recover via login/profile setup.

## App Integration Pattern

For Slack, Discord, email, or webhook apps, use this shape:

1. Verify the inbound request signature or bot token before accepting the task.
2. Deduplicate event ids or message ids to avoid duplicate browser runs.
3. Acknowledge quickly if the platform has a short response deadline.
4. Run Browser Use asynchronously in a worker or background task.
5. Use headless or cloud browser defaults in production; use cloud profiles for logged-in accounts.
6. Return `history.final_result()` or structured output, not raw chain-of-thought or secrets.

Read `references/integrations-and-monitoring.md` for platform-specific patterns.

## Observability

- For Browser Use anonymous telemetry, set `ANONYMIZED_TELEMETRY=false` before importing Browser Use to opt out.
- For cloud sync and hosted run views, authenticate with Browser Use Cloud and keep sync enabled.
- For third-party monitoring, Laminar and OpenLIT patterns are evidence-backed; keep vendor keys in environment variables.
- For production support tickets, collect task id/session id, live URL if safe, timestamps, model name, Browser Use version, and sanitized error logs.

## Troubleshooting Entry Points

- `ValueError: BROWSER_USE_API_KEY environment variable is not set`: set it in the process environment used by the app, worker, MCP client, or sandbox caller.
- `MCP SDK not installed`: install Browser Use with CLI/MCP-capable extras or add `mcp` to the environment; then retry the MCP command.
- Sandbox has no live URL: add `on_browser_created` callback and check API key/cloud connectivity.
- Cloud skill reports missing cookie: run with an authenticated cloud profile or navigate/login so required cookies are available.
- App integration times out: acknowledge immediately and move Browser Use work to a background task.
- Telemetry concerns: set `ANONYMIZED_TELEMETRY=false` and restart the process.

Read `references/troubleshooting.md` for step-by-step diagnostics.

## Handoff Checklist

Before returning a production integration answer:

- State which runtime mode is being used: local code plus cloud browser, `@sandbox`, REST Cloud API, MCP, hosted skills, or external app integration.
- List required env vars without revealing values.
- Include one short validation command or import check.
- Mention safe defaults: `ChatBrowserUse`, profile sync for auth, domain restrictions with secrets, and runtime/session caps.
- Cross-link sibling sub-skills only for their owned details.