cloud

Overview of cloud skill

What the cloud skill is for

The cloud skill is a documentation-driven helper for Browser Use Cloud, the hosted browser automation platform and API. It is best for people who need to automate websites through the cloud service, use the REST API or SDKs, connect external browser tools over CDP, or design workflows around sessions, profiles, proxies, and live monitoring.

Who should install this cloud skill

Install this cloud skill if your real job is one of these:

• start Browser Use Cloud quickly without reading every reference file
• choose between v2 REST API, v3 agent API, SDK usage, or direct browser connection
• automate browser tasks from Python, TypeScript, cURL, or external tools
• run browser automation in hosted infrastructure for Browser Automation use cases
• work with sessions, persistent profiles, residential proxies, CAPTCHA handling, or webhooks

Do not install it if you actually need help with the open-source local browser-use Python library configuration. The skill itself explicitly separates cloud usage from the open-source agent package.

What makes this cloud skill different from a generic prompt

A generic prompt can describe browser automation at a high level. This cloud skill is more useful when you need the exact Browser Use Cloud paths: which API version to read, how auth works, where liveUrl comes from, how cloud sessions differ from one-off runs, how CDP access is started, and what integration pattern fits your stack.

The biggest value is navigation and fit guidance, not hidden tooling. It points you to the right reference file fast:

• references/quickstart.md for first setup and pricing
• references/api-v2.md for stable REST endpoints
• references/api-v3.md for the newer session-based agent API
• references/browser-api.md for Playwright, Puppeteer, Selenium, and raw CDP
• references/sessions.md for session and profile design
• references/features.md for proxies, webhooks, workspaces, skills, MCP, and live view
• references/patterns.md for parallel runs, streaming, geo-scraping, and structured output

Best-fit use cases for cloud for Browser Automation

This cloud skill is especially relevant when you want cloud for Browser Automation rather than local browser control. Common fits include:

• scraping or extraction that benefits from stealth and proxies
• authenticated workflows that need persistent browser profiles
• remote browser sessions you can observe through liveUrl
• direct automation from Playwright, Puppeteer, or Selenium via hosted CDP
• integrations with agent systems, chat UIs, no-code tools, or webhook-driven backends

Main adoption blockers to check first

Most install decisions come down to a few practical questions:

• Do you need hosted cloud automation or local open-source control?
• Do you want stable v2 REST endpoints or the newer v3 session/message model?
• Do you need simple run() tasks, or explicit session/profile management?
• Are you using SDKs, cURL, or external browser frameworks over CDP?
• Do you need geographic routing, authentication persistence, or webhook callbacks?

If those questions are unresolved, this skill helps, because the repo is organized by decision path rather than one linear tutorial.

How to Use cloud skill

Install the cloud skill

Use the standard skills installer against the repository and target the cloud skill:

npx skills add https://github.com/browser-use/browser-use --skill cloud

After install, call it when your request is specifically about Browser Use Cloud, not the local open-source package.

Start with the right file for your goal

Read by decision, not by file order:

• New to the platform: references/quickstart.md
• Need stable API coverage and cURL examples: references/api-v2.md
• Need the newer agent/session model: references/api-v3.md
• Need hosted browser access from existing browser frameworks: references/browser-api.md
• Need persistent state, auth, or profile strategy: references/sessions.md
• Need advanced features like proxies or webhooks: references/features.md
• Need implementation patterns: references/patterns.md

This matters because the skill does not hide product complexity; it helps you choose the shortest useful reading path.

Understand the four main cloud usage paths

Before prompting, decide which of these you want:

1. run() task execution through SDK
2. v2 REST API task/session/browser endpoints
3. v3 agent API with sessions, messages, and workspaces
4. direct CDP browser connection for Playwright, Puppeteer, or Selenium

Many weak prompts fail because they ask for “Browser Use Cloud usage” without naming the intended path.

Set up authentication correctly

Browser Use Cloud uses the X-Browser-Use-API-Key header, and SDKs commonly read BROWSER_USE_API_KEY from the environment.

export BROWSER_USE_API_KEY=your-key

Useful details surfaced by the references:

• API base for v2: https://api.browser-use.com/api/v2
• API base for v3: https://api.browser-use.com/api/v3
• API key creation: https://cloud.browser-use.com/new-api-key

If your prompt does not mention how you want auth handled, the answer may stay too abstract.

Choose SDK, REST, or CDP before asking for examples

Use SDK examples when you want the simplest developer experience.
Use REST when you need endpoint-level control.
Use CDP when you already have browser automation code and just need a hosted browser target.

That distinction changes the answer materially:

• SDK answers focus on run(), sessions, profiles, and structured output
• REST answers focus on endpoints, polling, schemas, and headers
• CDP answers focus on WebSocket URLs and integration with browser tools

Turn a rough goal into a strong cloud usage prompt

Weak prompt:

Help me use Browser Use Cloud.

Better prompt:

I want cloud usage guidance for Python. I need a hosted browser workflow that logs into a site, persists cookies across runs, uses a US proxy, and lets me monitor progress live. Show whether I should use run() with auto-created sessions or manual sessions with a profile, and point me to the exact repo files to read first.

Why this is better:

• names language
• names workflow type
• mentions session persistence
• includes proxy requirements
• asks for live monitoring
• asks for file routing, not just code

Input details that improve output quality

For better cloud skill output, include:

• language: Python, TypeScript, cURL
• API mode: v2, v3, or unsure
• execution style: one-shot task, multi-step session, or direct browser control
• state needs: stateless vs persistent profile
• infra needs: proxy country, custom proxy, timeout, screen size
• monitoring needs: liveUrl, streaming, webhooks
• output shape: free text vs structured schema
• integration target: Playwright, Puppeteer, Selenium, chat UI, subagent, no-code tool

Without those, the answer will usually be accurate but too broad to implement quickly.

Use the cloud skill for session and profile design

A major practical value of the cloud skill is helping you avoid bad session design.

From the references:

• run() usually auto-creates a session
• manual sessions are better for multi-step workflows
• profiles persist cookies and local storage across sessions
• concurrent sessions using the same profile start from a snapshot and do not see each other's state changes

That last point is easy to miss in a quick skim and matters for authenticated parallel work.

Use the cloud skill for Browser Automation frameworks

If you already use Playwright, Puppeteer, or Selenium, the best path may be direct cloud browser access rather than agent tasks.

The repo shows a CDP entry point like:

wss://connect.browser-use.com?apiKey=YOUR_KEY&proxyCountryCode=us&timeout=30

This is important because the browser can auto-start on connect and auto-stop on disconnect, which is a different operating model than manually creating and tearing down tasks.

Use the cloud skill for advanced cloud features

This skill is also useful when your decision depends on platform features rather than syntax:

• stealth defaults
• residential proxies in many countries
• custom proxies
• CAPTCHA handling
• webhooks with signature verification
• live viewing and share links
• workspaces
• skills and marketplace support
• MCP-related platform references

These are the kinds of details that determine whether Browser Use Cloud fits production needs.

Recommended first workflow after install

A practical sequence for new users:

1. Read references/quickstart.md
2. Run a trivial first task through SDK or cURL
3. Decide whether your real workflow needs manual sessions
4. Add profiles only if you need persistent login or state
5. Add proxy and geography settings only when required
6. Add structured output or webhooks after the basic path works
7. Move to references/patterns.md for concurrency or streaming

This order reduces confusion and keeps you from over-designing before the first successful run.

cloud skill FAQ

Is this cloud skill only documentation, or does it change behavior?

It is primarily a reference-routing skill. Its value is helping an agent or user select the correct Browser Use Cloud documentation path and answer with fewer wrong assumptions. It does not replace the platform SDK or API.

Is the cloud skill good for beginners?

Yes, if you are a beginner to Browser Use Cloud specifically. The best starting point is references/quickstart.md. But you should still know whether you want simple task execution, session management, or framework-level browser control.

When should I not use this cloud skill?

Do not use this cloud skill for questions about the open-source browser-use local library internals, agent config, or non-cloud package setup. The skill explicitly says to use the open-source skill for that.

Should I use v2 or v3?

Use v2 if you want the stable REST API with broad endpoint coverage.
Use v3 if you want the newer BU Agent API model with sessions, messages, files, and workspaces, and you accept that it is marked experimental in the references.

Can this cloud skill help with ordinary browser frameworks?

Yes. The repo includes references/browser-api.md specifically for Playwright, Puppeteer, Selenium, and direct CDP connection to hosted browsers.

Is cloud for Browser Automation better than a normal prompt?

For Browser Use Cloud tasks, usually yes. A normal prompt may miss platform-specific facts like auth headers, endpoint versions, liveUrl, profile behavior, webhook signatures, or the auto-start CDP connection model.

Does the cloud skill cover pricing and operational constraints?

Yes, the quickstart reference includes pricing and FAQ material, and other references cover timeout, session handling, concurrency caveats, and feature-specific constraints.

How to Improve cloud skill

Ask for a decision, not just an explanation

The fastest way to improve cloud skill output is to ask it to choose among options:

• “Should I use v2, v3, or CDP?”
• “Should this be auto-session or manual session?”
• “Should I use a profile or keep it stateless?”

That produces implementation guidance instead of a broad summary.

Provide a concrete task and environment

Better:

I need cloud install and usage help for a TypeScript backend. The workflow logs into a dashboard weekly, downloads a file, and posts completion to my server. I need persistent auth, webhook notifications, and a recommendation between SDK and REST.

This improves results because it reveals language, cadence, state requirements, and completion signaling.

Tell the skill what must persist between runs

A common failure mode is under-specifying state. If login, cookies, local storage, or saved credentials matter, say so explicitly and ask for profile-based guidance from references/sessions.md.

If state does not matter, say that too. Then the skill can recommend simpler one-shot runs.

Specify whether you need observation or callbacks

Many users care about one of these but forget to ask:

• watch execution live with liveUrl
• stream step updates
• receive webhook callbacks when tasks finish

These lead to different implementation patterns and different files to read.

Ask for the minimal viable path first

A good improvement pattern is:

1. ask for the smallest working example
2. run it
3. then ask how to add profiles, proxies, or webhooks

This skill is strongest when it helps sequence adoption, not when it is asked to design the entire production architecture in one pass.

Watch for API-version confusion

One of the easiest ways to get weak output is mixing v2 and v3 concepts in one request. If you want comparisons, ask for a comparison. If you want implementation, name one version.

Good prompt:

Compare Browser Use Cloud v2 vs v3 for a multi-step agent workflow, then recommend one and give only that version's starter example.

Ask for file-level reading routes

The repo has enough reference material that targeted reading paths save time. Ask questions like:

• “Which file should I read first for webhook verification?”
• “Which reference covers CDP and Playwright setup?”
• “Which document explains concurrent sessions with the same profile?”

This makes the cloud guide more actionable than a generic summary.

Improve outputs with explicit success criteria

Instead of:

Show me cloud usage.

Use:

Show me a cloud usage path that gets from API key to first successful task in under 10 minutes, then list the next file to read if I need structured output.

Success criteria force the answer toward a practical adoption path.

Iterate after the first answer with gaps, not restarts

After the first response, improve it by naming what is still missing:

• missing auth handling
• missing polling example
• missing session cleanup
• missing proxy config
• missing structured output schema
• missing webhook verification
• missing Playwright connection details

That produces better second-pass guidance than asking from scratch again.

Best way to get high-value cloud guidance

The cloud skill performs best when your prompt includes:

• your stack
• your browser automation goal
• whether state must persist
• whether hosted browser control or agent execution is preferred
• whether you need monitoring, streaming, or webhooks
• whether you care about geo-routing or stealth constraints

That combination gives the skill enough context to route you to the right Browser Use Cloud material and produce guidance you can implement immediately.