Core concepts
The nine words the rest of this documentation uses: daemon, engine, profile, persona, seed, tier, lease, run and machine, and what each one decides for you.
Nine words carry the whole product. This page defines them once, so every other page can use them without explaining them again.
The daemon and the engine
Two programs, shipped separately, and neither works without the other.
The daemon is a single binary. It holds your profiles in a database, decides whether one may start, launches browsers, and serves every interface on this site: REST, MCP, the CDP socket, the AdsPower adapter and the management app. It never renders a page itself.
The engine is a Chromium fork we build and sign. It is the browser your profiles run in, and it is where the anti-detection work lives, because a value a page can read has to be true inside the browser rather than rewritten on the way out. The daemon verifies the engine's signature when you install it and again at every launch, and refuses to start a profile without a verified one.
They version independently. A daemon release may keep the engine you already have, and a new engine can be installed under a daemon you already run. What is fixed is the direction: a daemon states the oldest engine it accepts. See The engine.
Profile
A profile is one persistent identity. It owns a browser directory on disk (cookies, storage, history, extensions), a set of fingerprint values, optionally a proxy, and a row in the daemon's database.
Profiles are unlimited. What your plan limits is how many run at the same time, which is a different number. See Plans & limits.
A profile has a runtime_state, and it is one of four values:
| State | What it means |
|---|---|
stopped | No browser. The identity is on disk, untouched. |
starting | A launch is in flight, including the checks that may still refuse it. |
running | A browser is up and reachable. |
crashed | The browser died without being asked to. The next start is normal. |
Persona
The persona is the profile's set of fingerprint values: user agent, platform, screen geometry, GPU strings, timezone, locale, font set, device memory, and a few dozen more. It is created with the profile and does not change afterwards, which is the point: the same profile has to be the same machine every time it starts.
Not every value is chosen the same way, and the difference matters more than the list:
| Kind | Examples | Where the value comes from |
|---|---|---|
| Taken from the host | GPU, screen size, device pixel ratio | Read off the machine at create and at every launch. Anything a page can cross-check against the machine's own rendering is never invented. |
| Drawn from the seed | Timezone, locale, fonts, browser version, memory | Sampled deterministically. These have no hardware feedback, so a claim about them cannot be caught by the page itself. |
| Rewritten at launch | Timezone and locale under follow_exit | Follows the proxy's exit country, so the browser does not contradict the address it arrives from. |
Profiles & personas covers the full list and what you may constrain.
Seed
One random value per profile, stored with it. Every drawn axis of the persona comes from it, so the same seed produces the same identity down to the byte.
You can pass a seed when creating a profile to reproduce a known identity, for instance to rebuild a profile you lost. You cannot change it afterwards.
Tier
Which kind of host a profile runs on. There is exactly one, and it is the operating system underneath: a daemon launches the engine built for its own platform, and it launches only a profile whose identity claims that same platform. Today that is Windows.
Nothing selects this and nothing can. A profile whose identity was built for another operating system is refused at the pre-launch check with error 4005, rather than started with a browser that contradicts itself: an engine rendering on one system while claiming another is a contradiction a page finds in one comparison, which is the thing this whole product exists to avoid.
This used to be a field. Profiles carried a host_mode naming one of two tiers, one of which ran a Windows identity on a Linux host. That tier is gone, and so is the field. A client that still sends it is not refused; the daemon ignores the key.
Geo mode
What the daemon does when the profile's declared country and the proxy's real exit country disagree. Stored per profile as geo_mode:
geo_mode | On a mismatch |
|---|---|
follow_exit | The default. Timezone and locale are rewritten to the exit's cohort. An exit the daemon cannot identify is left alone rather than half-rewritten. |
strict_expected | The launch is refused with error 4002, including when the exit cannot be determined at all. |
off | Nothing is checked and nothing is rewritten. The profile may contradict its own address. |
Coherence & proxies is the page for what this actually compares.
Lease and handle
A lease is a reservation an agent holds on a profile over MCP. Taking one picks a free profile, starts its browser, binds a tab and returns a handle.
Every profile-scoped tool takes that handle, and no tool takes a profile id. That is what keeps one agent out of another agent's browser, and it is why an agent cannot address a profile somebody else is working.
A lease expires on its own, so a crashed agent does not hold a profile forever. The default is 900 seconds and the server clamps whatever a caller asks for.
Run
A run is one stretch of agent work with a stated goal, and the unit the activity view is built from. An agent opens one with start_run and everything it does afterwards is filed under it: every tool call becomes a numbered step with a timestamp, an outcome and, optionally, a still.
A run that nobody declared still exists. Work that arrives without a declaration opens one implicitly, so the trail has no holes. Activity & runs covers it.
Machine
Every install signs in to your account and becomes a machine on it. Two limits are counted there rather than locally:
- how many browsers may run at once across all your machines
- how many machines the subscription allows
A third rule is not a limit but a safety property: one profile runs on one machine at a time. Starting it on a second machine answers 4012 and names the machine holding it, because one identity signed in from two places at once is what a relying party reads as a cloned account.
Machines & sign-in covers pairing, takeover and removal.
Artifact
Anything a tool call produces that is too large to travel inside a reply: a screenshot, a downloaded file, a PDF, a recording. It comes back as an id, and the id is what a later call takes.
Artifacts belong to the profile that produced them. An agent cannot name a file path anywhere in this system, in either direction, which is why an upload takes an artifact id rather than a path.
Next
- Quickstart: the shortest path from nothing to an agent driving a page.
- Profiles & personas: what a profile is made of, in full.
- MCP server: how an agent gets a lease and works a page.