25
surfaces spoofed inside the engine
152
Chromium, built from source
168
curated fingerprints in the catalogue
0
wrapped functions for a page to find
Install in one command
Node, Python and MCP control the running desktop app through its authenticated loopback API. Docker provides the pinned Linux runtime for CI and farms.
pip install proxya-anty
export PROXYA_ANTY_API_TOKEN="..."
from proxya_anty import ProxyaAnty
anty = ProxyaAnty()
profile = anty.create_profile(platform="windows")
session = anty.start(profile["id"], headless=True)
print(session["cdp"]["web_socket_debugger_url"])
anty.stop(profile["id"])Two credentials, two separate jobs
For Node, Python and MCP, copy the Local API token from the desktop app under Settings → Local API. Docker uses PROXYA_ANTY_LICENCE from your proxya.co account under Settings → Proxya Anty. Neither value is your account password.
What the detectors say
Public detector runs from 29–30 August 2026, backed by the same automated acceptance and leak suites used for the release.
| Check | What it verifies | Release result |
|---|---|---|
| BrowserScanbrowserscan.net/bot-detection | Bot signal and browser authenticity | No bot detected |
| PixelScanpixelscan.net/fingerprint-check | Fingerprint consistency, masking and automation | Consistent · no masking · no automation |
| FingerprintJS OSSfingerprintjs.github.io/fingerprintjs | Visitor ID stability within a profile and separation between profiles | Stable per profile |
| SannySoftbot.sannysoft.com | Browser automation surfaces | 56 / 56 pass |
| Device & Browser Info | isBot and CDP automation signals | isBot: false · no CDP signal |
| Native acceptance | Engine-level fingerprint surfaces | 29 / 29 pass |
| Leak regression suite | Host values cannot escape the selected profile | 11 / 11 pass |
| TLS / JA4 | Transport fingerprint parity with Chromium 152 | Matches Chrome 152 |
What the engine handles itself
Each of these is answered from the profile at the point the browser computes it — not from a script layered on top.
Navigator
Platform, vendor, cores, memory, languages. Answered in Blink, where User-Agent Reduction reads them.
Canvas
Both readback paths — getImageData and toDataURL. Stable across reads, different from the machine underneath.
WebGL
Vendor and renderer strings, masked and unmasked, where ANGLE reports them.
Audio
Sample data perturbed once per buffer, so a page that reads twice sees no drift.
Fonts
The list the process can enumerate. Both document.fonts.check and the width-measuring trick get the same answer.
Client rects
Sub-pixel geometry, nudged in the report rather than in the layout — nothing on the page moves.
TLS handshake
The ClientHello, read before a line of script runs. Measured against stock Chrome on the same machine: the same JA4, to the character.
Text metrics
Windows returns a glyph's box in whole pixels and macOS in fractions, so a masked font list still measured in the host's fractions until this.
Media queries
Dark mode, reduced motion, forced colours. CSS asks the operating system directly, and the host was answering.
Timezone, locale and geolocation follow the proxy's exit country, and the exit itself is given a matching TCP fingerprint.
Built around the proxies you already have
The browser is one half of the disguise. The address it comes out of is the other, and a profile whose timezone argues with its exit IP has given itself away before the first page loads.
Your proxies, already in the list
Sign in and everything on your Proxya account is there — nothing to copy across by hand.
- Residential, ISP, datacenter and mobile, from the same account as the website
- Timezone, locale and geolocation resolved from the exit before the browser starts
- The exit is given a TCP fingerprint matching the operating system the profile claims
- Credentials sit in a loopback relay, so the browser is never asked for a proxy password
Devices that hold together
A fingerprint is not a list of random values. The GPU, the core count, the screen and the font list are drawn as one machine.
- A library of coherent devices rather than fields you fill in one at a time
- Canvas, audio and WebGL noise seeded per profile — stable for that profile, different from every other
- Choose from 168 curated fingerprints, or import one you already use
- Every value visible and editable, with the reason it matters written next to it
Drive it from a script
The same profiles, without a person clicking Launch.
Local API
An HTTP API on loopback, authenticated with a token, off until you turn it on.
- Start, stop and list profiles
- Create profiles and bind proxies
- Import and export cookies
SDKs and MCP
Wrappers for the two languages this gets written in, and a server an assistant can drive.
- Node and Python packages
- An MCP server with 39 tools
- Same auth as the API
Docker runtime
A pinned Linux x64 image for CI and farms, with the engine and SDK runtimes already installed.
- Versioned proxya/anty image
- Runs as a non-root user
- Licence supplied only at runtime
Automated, and still not read as automated
Automation reaches the profile through the local API and Chromium's debugging protocol; fingerprint changes remain inside the patched engine rather than being injected into the page.
- Attaching a debugger changes how the browser describes an error, and the widely used check reads exactly that. Here it reads nothing.
- It also makes a console call about fifteen times more expensive, which a page can time. The patched engine removes that measured difference.
- The release table compares the same public detectors, on the same day, against a stock Chrome driven by Playwright.
Questions people ask before downloading
Short answers, and where they are checkable, the way to check them.
No browser can promise that, and any that does is selling you something. What can be said is where the disguise lives: inside the engine rather than in a script layered on top, which removes the whole class of checks that compare a function against a clean copy of the browser. The rest — how you behave, whether your proxy is clean, whether the account history makes sense — is not something a browser controls.
A wrapper is a replacement function. A page can create a fresh iframe, take the original function from it, and compare — they differ. Proxya Anty changes the values where Chromium computes them, so the function a page inspects is the browser's own. The verification the engine ships with runs the binary with nothing but a profile file and reads back what a page sees; a stock Chromium fails every line of it.
No. Proxies you add by hand work exactly the same, and so do profiles and fingerprints. Signing in only saves you copying credentials: the proxies on your account appear in the list, and the exit's country is used to resolve the timezone and locale before the browser starts.
Nothing. It is free with a Proxya account, which is also what the proxies, the engine downloads and the licence hang off — so the account is required, and creating one costs nothing. There is no profile limit and no per-seat charge.
Yes. Release 1.0.0 includes Windows x64 and macOS Apple Silicon builds on GitHub. The current Mac build is ad-hoc signed rather than notarized, so the release includes a one-time Gatekeeper installation step. Linux x64 is available as the Docker runtime.
No browser can guarantee a verdict on every site, so we publish measured results instead. A stock Chrome driven over DevTools exposes automation signals unrelated to its fingerprint; the patched engine closes the tested error-stack, console-timing and WebDriver traces. Run the same public detection page through Proxya Anty and plain Playwright and compare the two results for your own workflow.
Yes. There is a local HTTP API on loopback, authenticated with a token and off until you switch it on, plus packages for Node and Python and an MCP server. Every profile also exposes DevTools, so Playwright and Puppeteer attach the way they would to any Chromium.