Skyvern + Scrapeless Scraping Browser: An AI Agent in the Cloud

Skyvern is a browser agent that decides what to do by looking at the page: it screenshots the screen, a vision model reads it, and the agent clicks, types, or reads based on what it sees. Point that agent's browser at the Scrapeless Scraping Browser over the Chrome DevTools Protocol and it drives a cloud Chromium with residential egress instead of a browser you run and hide on your own machine.

The pairing is a natural one. Skyvern supplies the reasoning — turn a plain-English goal into a sequence of browser actions — and the Scraping Browser supplies the runtime the agent acts in. This guide installs the Skyvern local runtime, points it at the Scrapeless Scraping Browser through a CDP connection, hands it a goal in one sentence, and watches it complete the task, with the agent run executed live against the cloud browser.

Why run Skyvern on the Scrapeless Scraping Browser

A vision agent is only as useful as the browser it drives. Run Skyvern against a local Chromium and you own the whole runtime: the browser process, its memory, its single exit IP, and whatever a busy site does to that IP. Point it at the Scraping Browser and that half moves to the cloud — the agent connects over CDP to a Chromium session Scrapeless renders and maintains, with residential egress you can pin to a country. The connection details it attaches to are the ones in the Scraping Browser documentation.

Nothing about the agent changes. Skyvern still screenshots, reasons, and acts; it simply acts inside a cloud browser reached through a WebSocket rather than a local one. That keeps the reasoning on your side and the browser fleet on Scrapeless's side, which is the split you want when a goal spans many pages or a site is selective about the traffic it serves.

Prerequisites

You need Python 3.11 or newer, Skyvern's local extra, a Scrapeless API key for the browser session, and a key for a vision-capable model. Get the Scrapeless key on the free plan at app.scrapeless.com. Skyvern's local mode runs the agent in-process, so no separate server or database is required for the run below.

Install

Install Skyvern with the local extra, which pulls the embedded agent runtime:

pip install "skyvern[local]"

Configure

Two keys go in the environment: the Scrapeless key for the browser and the model key for the agent's vision calls.

export SCRAPELESS_API_KEY="your_scrapeless_api_key"
export OPENROUTER_API_KEY="your_model_api_key"

Point Skyvern at the cloud browser and run a task

Skyvern reads its browser and model configuration from settings, so set them in code before you build the client: BROWSER_TYPE=cdp-connect tells Skyvern to attach to an existing browser, BROWSER_REMOTE_DEBUGGING_URL is the Scrapeless CDP endpoint, and the OpenRouter settings select a vision-capable model. Then Skyvern.local() runs the agent in-process and run_task takes the goal as a sentence. The connection rides the Chrome DevTools Protocol over the WebSocket protocol:

import os
from urllib.parse import urlencode

TOKEN = os.environ["SCRAPELESS_API_KEY"]
CDP_URL = "wss://browser.scrapeless.com/api/v2/browser?" + urlencode(
    {"token": TOKEN, "sessionTTL": 300, "proxyCountry": "US"})

os.environ.update({
    "BROWSER_TYPE": "cdp-connect",
    "BROWSER_REMOTE_DEBUGGING_URL": CDP_URL,
    "ENABLE_OPENROUTER": "true",
    "OPENROUTER_MODEL": "google/gemini-2.5-flash-lite",
    "LLM_KEY": "OPENROUTER",
    "LLM_CONFIG_SUPPORT_VISION": "true",
})

import asyncio
from skyvern import Skyvern

async def main():
    skyvern = Skyvern.local(use_in_memory_db=True)
    task = await skyvern.run_task(
        prompt="Find the first quote on the page and report its author's name.",
        url="https://quotes.toscrape.com/",
        wait_for_completion=True,
        max_steps=3,
    )
    print("task status:", task.status)
    print("engine:", task.run_request.engine)

asyncio.run(main())

The agent connects to the cloud browser, works the goal, and finishes:

task status: completed
engine: skyvern-1.0

Get your API key on the free plan: app.scrapeless.com

What the agent actually did

Behind that one status line, Skyvern ran its loop against the Scrapeless browser. It captured a screenshot of the rendered page, sent the image to the vision model with the goal, and the model returned an action — here it recognized that the first quote and its author were already on screen and marked the goal complete. On a task that needs interaction, the same loop clicks a button, fills a field, or scrolls, screenshots again, and re-reads, up to the max_steps you set. Every one of those actions executes inside the cloud Chromium, not on your machine, and the proxyCountry on the connection decides where the traffic leaves from.

An agent that acts on your behalf still works inside a site's boundaries: point it at public pages, honor the site's terms and its the Robots Exclusion Protocol directives, and keep the step budget modest. The division of labor is the point: Skyvern owns the decisions and the Scraping Browser owns the browser. For another agent framework on the same runtime, the walkthrough on running Browser Use on Scrapeless covers the same connection from a different agent.

Conclusion

Skyvern turns a sentence into browser actions, and the Scrapeless Scraping Browser gives those actions a cloud runtime to happen in. Set BROWSER_TYPE=cdp-connect with the Scrapeless CDP endpoint, run Skyvern.local() with a vision-capable model, and the agent drives a cloud Chromium with residential egress — the run above completed a goal end to end with no local browser anywhere. Read what the runtime offers on the Scraping Browser product page and weigh agent volume, which spends both browser time and model tokens, against the pricing page before you scale.

Join our community to claim a free plan and compare notes with other developers building browser agents: Discord · Telegram.

FAQ

Q: What does Skyvern do that a script does not?

Skyvern decides the actions instead of you coding them. It screenshots the page, a vision model reads the screenshot against your goal, and the agent chooses what to click, type, or read — so it adapts to a layout it has not seen rather than following selectors you hard-coded.

Q: How does Skyvern connect to the Scrapeless Scraping Browser?

Through a CDP connection. Set BROWSER_TYPE=cdp-connect and BROWSER_REMOTE_DEBUGGING_URL to the Scrapeless endpoint wss://browser.scrapeless.com/api/v2/browser?token=..., and Skyvern attaches to that cloud Chromium instead of launching a local browser.

Q: Do I need a Postgres database or a running server?

Not for this. Skyvern.local(use_in_memory_db=True) runs the agent in-process with an in-memory database, which is enough to drive a task. A separate server and Postgres are only needed for the self-hosted Skyvern service, not the local run shown here.

Q: Which model does the agent use?

A vision-capable model, because the agent reasons over screenshots. The example routes to google/gemini-2.5-flash-lite through OpenRouter with LLM_CONFIG_SUPPORT_VISION=true; Skyvern also supports OpenAI, Anthropic, Gemini, and other providers through the same settings.

Q: How do I keep the agent from running too long?

Set max_steps on the task. Each step is one screenshot-reason-act cycle, so a small budget caps how many actions — and how many model calls — a single task can make before it stops.

Q: Where does the traffic come from?

From the Scrapeless cloud browser's residential egress, not your machine. The proxyCountry parameter on the connection URL pins that egress to a country, which is what a geo-gated page keys its content on.

Q: Can I run a different agent framework the same way?

Yes. Any agent that connects to a browser over CDP can attach to the same Scrapeless endpoint, so the runtime is shared across frameworks while each brings its own reasoning.