Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.rustybrowser.com/llms.txt

Use this file to discover all available pages before exploring further.

​
Overview

Rusty Browser is fully open source. You can run the entire stack on your own servers — no token billing, no subscriptions. You still bear your own server and infrastructure costs, but there are no platform fees. The codebase ships as pre-built binaries. You do not need a Rust toolchain to run it.
The cloud service at app.rustybrowser.com runs on separate infrastructure with its own frontend, premium proxy network, Ghost Stealth, guaranteed SLA, and serverless infinite concurrency. Self-hosting gives you full control; the cloud handles the scale.

​
What’s in the Repo

The repository is a Cargo workspace with five crates:
  • rusty-server — the HTTP API your clients talk to. Manages the browser registry in Redis, spawns agents via Flux, and runs the AI instruct engine.
  • rusty-agent — a single-browser gRPC node. One agent runs per browser. It launches Chromium directly via the WebDriver BiDi / CDP protocol through rustenium, applies fingerprint and identity layering via rustenium-identity, and accepts commands from the server over TLS gRPC.
  • rusty-cli — a terminal client for the HTTP API. See CLI docs.
  • rusty-common — shared types, Redis store, config, AI providers, and the Flux client.
  • rusty-proto — shared gRPC proto definitions.
There is also rusty-frontend, a Next.js dashboard for managing sessions visually. See Frontend docs.

​
Repositories

rusty-browser

Server, agent, CLI, and common libraries

rustenium

Browser engine (Chromium driver)

rustenium-identity

Fingerprint and identity layer

serverless-flux

Serverless scaling infrastructure

​
Easy Setup (Windows)

The interactive PowerShell setup script handles everything — downloading binaries, walking through configuration, and generating ready-to-use launch scripts. Best for local setups or anyone who wants to get running quickly. Prerequisites: Node.js v18+ (for the frontend), Redis running or accessible.

​
Run the setup script

powershell -Command "curl.exe -sSL https://raw.githubusercontent.com/dashn9/rusty-browser/main/setup.ps1 -o setup.ps1; & .\setup.ps1"
The script will:
  • Download rusty.exe, rusty-cli.exe, flux.exe, and flux-agent.exe into %LOCALAPPDATA%\RustyBrowser
  • Ask for your Redis URL, AI provider key and model, and optionally AWS/GCP credentials for cloud-based agent scaling
  • Generate rusty.yaml, flux.yaml, and all launch scripts
  • Optionally add everything to your PATH
If your machine is not publicly reachable from the internet (e.g. behind NAT), the script will prompt you to set up ngrok to tunnel the gRPC port and tell you the exact command to run.

​
Start the stack

Once setup completes: 
rusty-launch              # server only
rusty-launch -Frontend    # server + frontend dashboard
If Windows Terminal is installed, each component opens in its own tab. Otherwise they open in separate windows.

​
Initialize

Run this once before spawning any browsers. It generates TLS certs, registers the agent function with Flux, and deploys the agent binary: 
rusty-cli init
# or use the Initialize button in the frontend UI

​
Manual Setup

For users who want full control over configuration. Works on Windows, Linux, and macOS.

​
Step 1 — Download the binaries

Download the latest release for your platform from the GitHub releases page. You’ll need:
  • rusty / rusty.exe — the server
  • rusty-agent / rusty-agent.exe — the browser agent (spawned automatically per browser)
  • rusty-cli / rusty-cli.exe — the CLI (recommended)

​
Step 2 — Start Redis

winget install Redis.Redis
redis-server

​
Step 3 — Configure the server

Copy the example config and open it in an editor: 
Copy-Item example.rusty.yaml rusty.yaml
For local mode without Flux, set flux.local_binary to point at the agent binary: 
flux:
  local_binary: ".\rusty-agent.exe"
For production with Flux running separately, point to it instead: 
flux:
  base_url: "http://127.0.0.1:7227"
  api_key: "your-flux-api-key"
  function_name: "rusty-agent"

​
Step 4 — Start the server

$env:RUSTY_CONFIG = "rusty.yaml"
.\rusty.exe

​
Step 5 — Initialize

.\rusty-cli.exe init

​
Step 6 — Configure the CLI

.\rusty-cli.exe env set url http://127.0.0.1:8080
.\rusty-cli.exe env set api-key your-key-here

​
Step 7 — Verify

.\rusty-cli.exe browser spawn
.\rusty-cli.exe browser navigate https://example.com
.\rusty-cli.exe browser screenshot
.\rusty-cli.exe browser close-all

​
Setting Up Flux (Production Scaling)

Flux is the serverless control plane that rusty-server uses to spawn browser agents. In local mode it runs agents as subprocesses on the same machine. In production mode it provisions and autoscales agent nodes across AWS EC2 or GCP Compute Engine. The easy setup script configures Flux automatically. If you’re doing a manual setup or want to run Flux separately, here’s how.

​
Docker (GHCR)

docker run -p 7227:7227 \
  -v /path/to/flux.yaml:/etc/flux/flux.yaml \
  ghcr.io/dashn9/serverless-flux:latest

​
Windows binary

Download flux.exe from the serverless-flux releases page, create a flux.yaml from the example config, and run it: 
.\flux.exe
At minimum your flux.yaml needs: 
api_key: your-flux-api-key
redis_addr: localhost:6379
Add an aws or gcp provider block to enable cloud node provisioning and autoscaling. Flux handles SSH bootstrapping of agents, TLS cert generation, and scale-up/scale-down automatically. For full configuration options and the serverless agent worker setup, see the serverless-flux GitHub page.

​
Self-Hosted vs. Rusty Cloud

Self-HostedRusty Cloud
Platform costYour server costs onlyToken-based — see Pricing
Rust toolchain neededNo (pre-built binaries)N/A
ConcurrencyBound by servers you provideUnlimited serverless
Proxy networkYour own80M+ premium residential proxies
StealthCDP / BiDi NativeGhost Stealth (hardware-level)
SLANoneGuaranteed
Dashboardrusty-frontend (open source)Separate cloud frontend
AuthOptional (X-API-Key)Bearer token required