What's the difference between a browser agent and a web scraper?

A scraper follows a script you wrote — fetch these URLs, pull these fields. A browser agent is driven by an LLM that looks at the page, decides what to click or type, and adapts when the layout changes. browser-use, Skyvern and Anthropic's computer-use all work this way. It's the difference between a fixed crawler and an operator that reasons. If your task is deterministic extraction, see the scraping guide instead — this page is for the reasoning kind.

Do I need a GPU to run a browser agent?

No. The reasoning happens in an LLM you call over an API (Anthropic, OpenAI, etc.), so the server just runs a headless Chromium plus your agent loop — CPU and RAM work, not GPU. You'd only want a GPU if you also ran the model locally, which is a separate, much heavier setup.

How much RAM does it need?

The browser is the weight, not the agent. A headless Chromium instance is ~300-500 MB, plus 100-200 MB per open tab/context, plus your runtime. Small ($8, 4 GB) is a sane floor for one agent driving a browser; step up to Medium if you run several browser contexts in parallel.

Do I need a dedicated IP?

Usually no. A browser agent makes outbound requests — to the sites it operates and to the model API — so a NAT plan with forwarded SSH is enough and cheaper. Take a dedicated IP only if you also expose an inbound service (a control dashboard, a webhook receiver).

Is this allowed? What are the limits?

Legitimate automation of sites you're allowed to use — yes. Respect each site's terms and rate limits, don't hammer a target into a denial of service, and don't use it for fraud, credential stuffing or account abuse. That's an acceptable-use violation and gets the service terminated. A browser agent is a powerful operator; point it only where you have the right to act.

VPS for browser-use agents: run computer-use AI on a server 24/7

A web scraper follows instructions you wrote. A browser agent decides for itself: it looks at the rendered page, reasons about what to do next, and clicks, types and scrolls a real browser to get there. Tools like browser-use, Skyvern and Anthropic's computer-use turn an LLM into something that operates a browser the way a person would — filling forms, navigating flows, reading results, recovering when a layout shifts.

That only works if the browser is always running. On your laptop it stops the moment you close the lid. This page is about putting a browser agent on a server, sized correctly, so it operates around the clock.

Scraper vs agent — pick the right tool

Be honest about which you're building, because they want different things:

A scraper (httpx, Scrapy) fetches known URLs and pulls fixed fields. Deterministic, light, cheap. If that's your task, the web-scraping guide is the right page — don't pay for a browser you don't need.
A browser agent renders the page in a real Chromium and lets an LLM decide each action. It handles sites that a scraper can't — dynamic apps, unpredictable layouts, multi-step flows — at the cost of a heavier box and per-step model calls.

This page is the second one.

What the box actually needs

The agent loop itself is tiny; the headless browser is what uses resources.

RAM is the constraint. A headless Chromium is ~300-500 MB, and every extra tab or context adds 100-200 MB. One agent driving one browser is comfortable on Small ($8/mo — 4 vCPU, 4 GB). Running several browser contexts at once pushes you to Medium ($12).
No GPU. The model runs at your provider (Anthropic/OpenAI); the server does orchestration and rendering. That's CPU and RAM.
NAT is enough. The agent only makes outbound calls — to the sites it operates and the model API. A dedicated IP is only for inbound services.

The setup

# Ubuntu 24.04
apt update && apt install -y python3-venv git
python3 -m venv ~/agent && source ~/agent/bin/activate

# browser-use + a Chromium for Playwright
pip install browser-use
playwright install --with-deps chromium

A minimal loop reads its model key from the environment, never hard-coded:

# run.py
import os, asyncio
from browser_use import Agent
from browser_use.llm import ChatAnthropic

async def main():
    agent = Agent(
        task="Open the status page and report which services are down.",
        llm=ChatAnthropic(model="claude-sonnet-4-5", api_key=os.environ["ANTHROPIC_API_KEY"]),
    )
    await agent.run()

asyncio.run(main())

Keep it alive across crashes and reboots with a systemd service — the same pattern that keeps any agent running 24/7, with Restart=always and the model key in an EnvironmentFile, not the unit.

Watch the RAM. A browser agent that never closes tabs will slowly eat the box — close pages and contexts when a task ends, and cap concurrency. A leaked Chromium is the most common way one of these falls over.

The part that's actually ours: the agent can rent its own box

This is where EQVPS differs from a normal host. Over our MCP server an agent can register, top up a crypto balance, and order_vps a fresh machine on its own — no human at the checkout. So a browser agent that needs a clean environment for a run can provision the server itself, operate the browser, and tear it down when it's done, all from a prepaid balance.

Pair that with no-KYC crypto payment and the whole loop stays off any identity trail: email to sign up, USDC or USDT to pay, root in about a minute.

The honest limits

CPU-only, one region (Germany). Fine for driving a browser and calling an API; if you need a GPU or a specific geo, know that upfront.
Model cost is separate. Each step is a model call — a chatty agent's API bill usually dwarfs the $8 server. The box is the cheap part.
Respect where you point it. A browser agent can log in, submit and buy. Only aim it at sites you're allowed to operate; abuse, fraud and denial-of-service violate the acceptable use policy.

Within that, a browser agent on its own always-on server is a genuinely useful pattern — it operates while you sleep. Pick a plan, pay in crypto, and have one running in a minute. If your task is fixed extraction rather than reasoning, the web-scraping guide is the cheaper, simpler route.