Scrapium

Patches Blink/V8 source directly. 4,000+ signals coherent.

  • Anti-detect, proven in production. 5B+ scrapes/month on protected websites via the Scrapfly Web Scraping API.
  • Agentic by design. We patch, fix, and add features for agent workflows: permissions, popups, tab-switching prevention, download handling, and more.
Get Free API Key 1,000 free credits. No credit card required.
SCANNING
FINGERPRINT DATA LIVE
+ 4,000 more datapoints...
4,000+
Fingerprint Datapoints
200M+
Proxy IPs
50+
Anti-Bots

4,000+

signals patched at C++ level

550+

Chromium source files patched

345+

distinct GPU profiles across Windows / macOS / Linux

auto

tracks every Chrome upstream release


COVERAGE

Every Signal Patched

From TCP to behavior. One coherent identity across all layers.

Genuine Windows, macOS, Linux

Not a Linux process pretending to be Windows. Scrapium runs as an authentic Chrome build for each target OS. Windows Chrome renders with Windows fonts, Windows system colors, and the exact Blink build Chrome ships on that platform. The proxy chain guarantees OS-to-exit-peer alignment: a Windows browser always exits through a Windows peer, 100% coherent end to end. Same for macOS and Linux.

Windows
macOS
Linux
Every Signal Patched

4,000+ signals rewritten at Chromium source. Not monkey-patches. Not JS shims.

4,000+signals
550+files patched
C++not JS shims
Blinkrendering engine
V8JS runtime
Skia2D graphics
MojoIPC layer
Patched Bottom To Top

From the network layer up. Every signal the browser exposes is rewritten at the layer it actually comes from, not spoofed on the way out.

Chrome Browser navigator, canvas, WebGL, audio, plugins
GPU genuine GPU profile, not a spoofed renderer string
CPU hardwareConcurrency, perf timing coherent
Memory deviceMemory, allocation pattern jitter
Host OS device aligned to the proxy exit peer
Network Over Proxy HTTP/3, WebRTC, DNS-over-HTTPS. All tunneled via UDP proxy, no leaks
Stays Current

Auto-tracks every Chrome release. Your traffic matches what real users run today, not last quarter.

3 daysmax lag from GA
Bypasses Every Major Antibot

Tested against production antibot stacks. Consistent pass rate across vendors.

See full bypass coverage
Human-Like Behaviors

Emulates genuine human input. Indistinguishable from a real user session.

Mousecursor pathing
Keyskeymap + OS binding
Scrollvelocity
End-To-End Geo Coherence

Proxy IP, timezone, locale, and language all agree. Detection systems flag any mismatch across the chain. Scrapium aligns every link automatically: proxy exit country decides timezone, timezone decides browser locale, locale decides languages, voices, text direction, and translation surface.

Proxy Exit IP country, ASN, residential vs datacenter
Timezone IANA TZ matches proxy country, DST-aware
Browser Locale navigator.language, Accept-Language, Intl APIs (date format, currency, number format)
Voices + Text Direction SpeechSynthesis voices, RTL/LTR, translation surface
Extension Support

Real users run extensions. Headless browsers usually don't, and detection systems use that as a signal. Scrapium covers both sides.

Spoof Installed Extensions appear to carry common extensions (adblockers, password managers) without running them
Load Custom Extensions ship your own extension, manifest v2 or v3, for agentic workflows
Localized DNS + Session Cache

Bots re-resolve DNS, re-handshake TLS, and re-negotiate HTTP/2 on every request. Real Chrome caches aggressively and returns fast on revisit. Scrapium mimics both the speed and the pattern.

Localized DNS resolvers
Per-session IP cache
TLS session resumption
Enriched Chrome DevTools Protocol

Scrapium extends the Chrome DevTools Protocol with extra domains for stealth controls, fingerprint overrides, session resumption, and file downloads. Drop-in compatible with Playwright, Puppeteer, Selenium, and Stagehand. Use the tools you already know, with capabilities genuine Chrome can't offer.

Read CDP reference
FAQ

Frequently Asked Questions

WHAT IS SCRAPIUM?

Scrapium is Scrapfly's proprietary stealth browser, built on Chromium. Chromium is the open-source codebase that Google Chrome itself is built on: same engine, same rendering, same wire format. Chrome adds proprietary Google services on top; Scrapium adds stealth patches and agentic features instead. It patches 4,000+ signals at the C++ engine level (not in JavaScript) across WebGL, Canvas, AudioContext, Navigator, Screen, WebRTC, DRM, font rendering, and sensors. Values are seeded deterministically per profile so every session is internally coherent.

IS SCRAPIUM PROVEN AT SCALE?

Yes. Scrapium runs behind the Scrapfly Web Scraping API at 5B+ scrapes per month against protected websites. Every Scrapfly customer hitting a target that needs a full browser is running through Scrapium without ever configuring it directly. Production workload, production detection vendors, production pass rates.

WHAT AGENTIC FEATURES DOES SCRAPIUM ADD?

Scrapium is tuned for agent workflows (Playwright, Puppeteer, Selenium, Stagehand). We patch, fix, and extend Chrome capabilities specifically for automated and AI-driven use: programmable permission handling, popup and dialog control, tab-switching prevention, download handling, session resumption, and an enriched Chrome DevTools Protocol (extra CDP domains that genuine Chrome does not expose). Your agent framework sees a compliant Chrome, plus the hooks agents actually need.

CAN SCRAPIUM EMULATE DIFFERENT OPERATING SYSTEMS?

Yes. Scrapium runs as an authentic Chrome build for Windows, macOS, and Linux. Windows Chrome renders with Windows fonts, Windows system colors, and the exact Blink build Chrome ships on that platform. The proxy chain guarantees OS-to-exit-peer alignment: a Windows browser always exits through a Windows peer, 100% coherent end to end. Same for macOS and Linux.

DO I CONFIGURE SCRAPIUM SEPARATELY?

No. Scrapium is part of the Scrapfly infrastructure and is selected automatically when the Scrapfly protection system determines it is the right tool for a given target. You call the standard Scrapfly scrape API. Browser selection, fingerprint profile assignment, and patch seeding all happen server-side.

HOW DOES SCRAPIUM STAY CURRENT WITH CHROME?

Our browser-engineering team auto-tracks every Chrome release. When a new Chrome stable ships, Scrapium ships the same patch target into the browser pool within days, maximum 3-day lag from GA, fully automated. No customer config, no version-lag fingerprint signal. Most stealth browsers run two or three versions behind, which is itself a detection signal: real users update Chrome automatically.

HOW DOES SCRAPIUM MIMIC BROWSER CACHING?

Detection systems time the sequence of DNS resolution, TLS handshake, and HTTP/2 negotiation. Real browsers on a return visit are fast because DNS is cached and TLS session tickets let 0-RTT resume. Most automated browsers re-resolve and re-handshake every request, which is a tell. Scrapium uses localized DNS resolvers geo-aligned to the proxy exit region, caches resolved IPs per session, and replays TLS session tickets when the server allows.


// DUO

Alternate Scrapium and Curlium without getting caught.

Best of both worlds on the same target session. Use Curlium (HTTP client, 10-50x faster) when a page doesn't need JavaScript. Switch to Scrapium when it does. Same JA4 hash, same Chrome version, same proxy IP, same Accept-Language. Detection systems never see a fingerprint change mid-session.

  • Same JA4 hash. Curlium and Scrapium emit identical TLS fingerprint.
  • Same Chrome version. Both auto-tracked, never out of sync.
  • Auto-routed per target. Scrapfly picks the right tool, you don't configure it.