Repository navigation
wrap invisible playwright in a fastapi service
To wrap invisible_playwright in a FastAPI service, start one browser in the app's lifespan instead of one per request, hand each incoming request a fresh page from it, bound concurrency with an asyncio semaphore, and return the result as rendered HTML or a screenshot using stock Playwright calls. This is a common next step once the first script works: putting the browser behind an HTTP endpoint so other services can ask for a page or a screenshot without carrying a browser of their own.
This page also answers the question honestly. A shared render endpoint helps with the part invisible_playwright is built for - the browser looks like a genuine Firefox driven by a person, so the fingerprint, TLS and driver layers read as real. It does nothing for the part you have just made worse: every caller now leaves from the same address, which is its own detectable pattern. Both halves are below.
Launching a browser is the expensive part. It downloads nothing after the first run, but it still starts a process, reads the profile, and builds the identity before the first page loads. Doing that on every HTTP request means every caller pays that cost, and a burst of callers starts a burst of processes that compete for the same CPU and memory.
The fix is the ordinary one for any expensive resource behind a web server: create it once when the app starts, hand every request a page from it, and close it once when the app stops. In FastAPI that lifecycle hook is the lifespan context. One browser, many pages.
A single browser serving many pages is also the shape that matches how the
identity works. One launched browser is one seeded machine. If you want every
caller to share a stable, reproducible fingerprint, pass a fixed seed at
startup and every page inherits it. If you would rather each caller look like a
different machine, that is a different design - a small pool of browsers, or a
launch per identity - and it costs more, so decide it on purpose.
Here is the whole thing. It keeps one browser for the process lifetime, hands each request a fresh page, and returns the rendered HTML.
from contextlib import asynccontextmanager, AsyncExitStack
from fastapi import FastAPI, HTTPException
from fastapi.responses import HTMLResponse
from invisible_playwright.async_api import InvisiblePlaywright
state = {}
@asynccontextmanager
async def lifespan(app: FastAPI):
# started once, when the process comes up
async with AsyncExitStack() as stack:
browser = await stack.enter_async_context(InvisiblePlaywright(seed=42))
state["browser"] = browser
yield
# AsyncExitStack closes the browser here, once, on shutdown
app = FastAPI(lifespan=lifespan)
@app.get("/render", response_class=HTMLResponse)
async def render(url: str):
browser = state["browser"]
page = await browser.new_page()
try:
await page.goto(url, wait_until="networkidle")
return await page.content()
except Exception as exc:
raise HTTPException(status_code=502, detail=str(exc))
finally:
await page.close()The browser object is a real
playwright.async_api.Browser,
so new_page, goto, content and every other method behave exactly as documented upstream.
There is no wrapped subset to learn - the only thing that differs from plain
Playwright is the two-line launch. Run it with any ASGI server, for example
uvicorn app:app, and GET /render?url=https://example.com returns the page as
the browser saw it.
Closing the page in finally matters. A page you forget to close is memory the
browser holds until it shuts down, and a service that leaks a page per request
is a service that falls over on the day it gets busy.
A render service that just launches a page per request has a quiet flaw: nothing limits how many pages open at once. Ten callers arriving together open ten pages together, a hundred open a hundred, and each page is real memory and a real share of one CPU. A single browser does not protect you from this - it just means all those pages crowd into one process.
An asyncio.Semaphore fixes it in a few lines. It lets a fixed number of
renders proceed and makes the rest wait their turn instead of piling on.
import asyncio
from contextlib import asynccontextmanager, AsyncExitStack
from fastapi import FastAPI, HTTPException
from fastapi.responses import HTMLResponse
from invisible_playwright.async_api import InvisiblePlaywright
MAX_CONCURRENT_RENDERS = 4
state = {}
@asynccontextmanager
async def lifespan(app: FastAPI):
async with AsyncExitStack() as stack:
browser = await stack.enter_async_context(InvisiblePlaywright(seed=42))
state["browser"] = browser
state["gate"] = asyncio.Semaphore(MAX_CONCURRENT_RENDERS)
yield
app = FastAPI(lifespan=lifespan)
@app.get("/render", response_class=HTMLResponse)
async def render(url: str):
async with state["gate"]: # waits if 4 renders are already busy
page = await state["browser"].new_page()
try:
await page.goto(url, wait_until="networkidle")
return await page.content()
except Exception as exc:
raise HTTPException(status_code=502, detail=str(exc))
finally:
await page.close()Pick the limit from the machine, not from a wish. Each concurrent page wants
memory and a slice of CPU, so a small server holds a handful, not fifty. Set it
too high and every render slows down together under load; set it sensibly and
callers queue for a moment instead of the whole box thrashing. If you want to
fail fast rather than queue forever, wrap the acquire in asyncio.wait_for and
return a 503 when the wait runs out.
A render service built the same way returns a PNG with one different call:
swap page.content() for page.screenshot(). A screenshot endpoint is
useful precisely because a text log tells you what your extractor found, while
the image tells you what the page actually rendered - the distinction that
reading the screenshot instead of the log is
built on.
from fastapi import Response
@app.get("/shot")
async def shot(url: str, full_page: bool = False):
async with state["gate"]:
page = await state["browser"].new_page()
try:
await page.goto(url, wait_until="networkidle")
png = await page.screenshot(full_page=full_page)
return Response(content=png, media_type="image/png")
finally:
await page.close()page.screenshot
is stock Playwright, so full_page=True captures past the
fold exactly as it does everywhere else - the mechanics and the pitfalls of the
tall capture are in
how to take full-page screenshots.
This is the part a service shape makes easy to forget, so it gets its own section.
The moment you put one browser behind one endpoint on one host, every caller
that hits /render leaves the internet from the same address. The fingerprint
is still real and still per-session - each page is a genuine Firefox - but you
have concentrated all of that traffic behind a single IP, and volume from one
address is a signal no browser realism touches. A hundred callers behind your
service look, from the far end, like a hundred requests from one machine, which
is a pattern in its own right regardless of how convincing each request is.
invisible_playwright is designed to look like a real browser driven by a real person, and that is why it clears most fingerprint, TLS and driver-layer checks. It does not, on its own, fix IP reputation, per-account quotas, rate limits, or the timing of your requests. Those are yours to supply. For a render service the practical shape is:
- Give the service a clean egress, not the datacenter IP the host boots with. Route the browser through a proxy per request or per identity - the proxy rotation patterns page covers doing this without relaunching the browser every time, and Configuration covers the proxy dict and how the timezone follows the exit.
- Pace the work. A semaphore bounds concurrency on your side; it does nothing about how fast one destination sees requests arrive. Space them.
- Remember what no in-page realism can help with, the machine-and-behaviour tells that the detection checklist works through in order. A shared endpoint does not add any of that, and it can subtract from it by centralising the address.
None of this is a reason not to build the service. It is a reason to build the egress and the pacing alongside it, rather than shipping the render endpoint and discovering the address problem in production.
A FastAPI render service around invisible_playwright is a small amount of code: a lifespan that starts one browser and stops it once, a semaphore that keeps a burst of callers from spawning unbounded pages, and an endpoint that returns HTML or a PNG using stock Playwright methods. The browser realism comes for free with the two-line launch.
What does not come for free is the network shape you have just created. One endpoint means one address, and one address carrying everyone's traffic is a detectable pattern that a perfect fingerprint does not undo. Build the clean egress and the pacing as part of the service, not as a fix later.
Should I launch a browser per request? No. Launching is the expensive part, so start one browser in the FastAPI lifespan and hand each request a fresh page from it. Close the page when the request ends.
How do I keep one browser alive across requests? Enter the
InvisiblePlaywright async context in the lifespan startup and let it exit on
shutdown, keeping the returned Browser in app state. An AsyncExitStack does
the enter-and-later-exit cleanly.
How do I stop a traffic burst from spawning too many pages? Guard the render
with an asyncio.Semaphore sized to the machine. Callers past the limit wait
their turn instead of piling more pages onto one browser.
Does one shared endpoint make me undetectable? No. Each session's fingerprint is real, but every caller now leaves from the server's single IP, and volume from one address is its own signal. Realism does not fix reputation or rate.
Do I still need a proxy if the browser looks real? Yes for most real targets. The browser layer clears fingerprint and driver checks; the IP, per-account limits and pacing are separate and yours to supply.
Can I return a screenshot instead of HTML? Yes. Swap page.content() for
page.screenshot() and return the bytes as image/png. It is stock Playwright,
full_page=True and all.
- This project's Quickstart and Configuration pages for the launch, the async entry point, the proxy dict and the auto-derived timezone.
- FastAPI documentation, Lifespan Events, and Python documentation, asyncio.Semaphore and contextlib.AsyncExitStack, retrieved 2026-08-29.
- This set's own testing notes on why an address and its rate survive a perfect fingerprint, and why the screenshot beats the log.
See also: how to rotate proxies without relaunching, the detection checklist in the order that matters, and how to test whether the result is actually detected.
Written while maintaining invisible_playwright, a Firefox patched at the C++ level driven by stock Playwright. The service shape is easy; the single-IP cost is the part people ship without noticing.
Documentation
- Installation
- Quickstart
- Configuration
- Pinning fingerprint fields
- CLI reference
- Differences from Playwright
Guides
-
Browser Identity
- navigator.webdriver is not the tell you think it is
- hardwareConcurrency, deviceMemory and storage quota
- Screen size and viewport tells in headless browsers
- Playwright headless vs headed: what detectors see
- Playwright User Agent: Why You Should Not Set It
- Client Hints and Sec-Fetch: headers that must agree
- Codec fingerprinting: canPlayType and MediaCapabilities
- Permissions API: the two answers that must agree
- CSS fingerprinting: what media queries reveal
- What privacy.resistFingerprinting actually does
- speechSynthesis.getVoices() returns an empty array
- Browser extensions are a fingerprint surface
- BFCache and pageshow.persisted under browser automation
- Service workers, storage partitioning and automation
- Web Workers: where page-level fingerprint patches fail
- fake-useragent is archived: what changes and what doesn't
- navigator.buildID and the stale build date tell
- navigator.maxTouchPoints and pointer consistency
- navigator.platform and oscpu on a spoofed OS
- navigator.vendor and productSub: the Firefox tells
- Accept-Language header vs navigator.languages
- window.devicePixelRatio: the pref that spoofs it
- Can you be fingerprinted in incognito mode?
- Is changing the user agent enough to avoid detection?
- Can a website tell you are running on a server?
- Can two devices share a browser fingerprint?
- Does clearing cookies stop fingerprint tracking?
- Color-gamut and HDR media queries as a fingerprint
- Battery API fingerprint: does Firefox expose it?
- Is navigator.connection a fingerprint in Firefox?
- Can the Gamepad API fingerprint or detect a bot?
- Do accelerometer and gyroscope APIs leak on desktop?
- prefers-reduced-motion and other OS-setting tells
- Does storage quota estimate reveal disk size?
- Can scrollbar width reveal my operating system?
-
Canvas, WebGL, Fonts and Audio
- Canvas fingerprint noise: why per-call randomising fails
- Firefox WebGL renderer strings: what ANGLE reports
- WebGL parameters: the numbers are the same on every GPU
- Your renderer string says NVIDIA. Your pixels say software.
- Why headless browsers render different fonts
- How to make Linux and macOS report real Windows fonts
- measureText and TextMetrics as a fingerprinting surface
- AudioContext fingerprinting, and why adding noise backfired
- Canvas and WebGL fingerprints across OSes
- Emoji fingerprinting: why emoji look the same on any OS
- Detecting installed fonts in JavaScript by width
- WebGL shader precision as a fingerprint surface
- AudioContext sampleRate and latency as a fingerprint
- Is WebGPU a browser fingerprint?
- Why the same canvas draws differently on Windows and Linux
-
Network, Proxy and WebRTC
- WebRTC leak with a proxy in Playwright and Selenium
- WebRTC ICE candidate spoofing: the fields that give it away
- Playwright proxy in Python: per-context, and what leaks
- Playwright proxy not working? SOCKS5 auth in Python
- Playwright timezone does not match the proxy IP
- JA3 and JA4: why a TLS fingerprint cannot be patched
- Playwright in Docker: it runs, and still gets blocked
- Web scraping keeps getting blocked with good proxies
- Python web scraping blocked? The TLS fingerprint reason
- SOCKS5 vs HTTP proxy: what each does in the browser
- WebRTC IPv6 leak: why a proxy does not stop it
- HTTP/2 fingerprint: the layer above the TLS handshake
- TLS fingerprint vs User-Agent: the contradiction
- WebRTC has no ICE candidates behind a proxy
- WebRTC IP that matches the proxy exit, by design
- How to check if a proxy leaks your real IP
- about:webrtc: read your real ICE candidates
- Offline timezone resolution from a proxy exit IP
- Residential vs datacenter vs mobile proxies explained
- Sticky vs rotating proxy sessions: which to use
- Does a proxy leak DNS? DoH and DNS leaks explained
- HTTP/3 and QUIC fingerprint: what a site sees
- What is ASN and IP reputation in bot detection?
- What does a mobile carrier IP look like to a site?
- IPv6 vs IPv4: which does your proxy expose?
- Geolocation API vs IP location: keep them consistent
- Does chaining two proxies help avoid detection?
- ERR_HTTP2_PROTOCOL_ERROR in Playwright: causes and how to diagnose it
- ERR_TUNNEL_CONNECTION_FAILED in Playwright: what it means and how to fix it
- ERR_SOCKS_CONNECTION_FAILED in Playwright: what it means and how to fix it
- net::ERR_CONNECTION_RESET in Playwright
- net::ERR_PROXY_CONNECTION_FAILED in Playwright
- net::ERR_ABORTED in Playwright
- net::ERR_NAME_NOT_RESOLVED in Playwright
- net::ERR_CERT_AUTHORITY_INVALID in Playwright
- net::ERR_EMPTY_RESPONSE in Playwright
- net::ERR_CONNECTION_REFUSED in Playwright
- net::ERR_INVALID_AUTH_CREDENTIALS in Playwright
- JA4H: The HTTP-Header-Order Fingerprint, Explained
- How to check a proxy's status before you rely on it
-
The Automation Layer
- Function.prototype.toString and the [native code] check
- The ChromeDriver
cdc_variable, and why renaming it fails - Why an attached debugger makes automation detectable
- Execution context was destroyed, and when it means detection
- Human-like mouse movement: Bezier curves are the easy part
- Why a Playwright upgrade broke 97 of 133 tests overnight
- Playwright persistent profile: what it fixes and breaks
- Why humanized mouse movement can fail on hover()
- Why content_frame() returns None for a cross-origin iframe
- Orphaned Firefox processes on Windows: the killed-runner leak
- Firefox launches but Playwright can't drive it: packaging gap
- Why automating login is riskier than reusing a session
- Playwright new_page vs new_context: the viewport tell
- Playwright dialog and popup handling without a tell
- Playwright download files with Firefox and the tell
- Playwright connect_over_cdp does not work with Firefox
- Playwright mobile emulation on Firefox and isMobile
- Playwright isTrusted: are automated clicks real?
- Playwright set_input_files uploads and the tell
- Can websites detect Playwright? What is actually visible
- Does Playwright Set navigator.webdriver to True?
- Does Playwright Leave Traces a Website Can See?
- Does Playwright Change My Browser Fingerprint?
- Can I Use My Real Browser Profile With Playwright?
- Does Playwright Support Firefox Stealth?
- Is Playwright Firefox Harder to Detect Than Chromium?
- Does Playwright Get Detected on the First Request?
- Why Playwright's bundled Firefox is easy to detect
- ghost-cursor human mouse paths with Playwright
- Stock Playwright, patched Firefox: how they connect
- Intercept and mock network requests with page.route
- Record and replay HTTP traffic with HAR in Playwright
- Record a Playwright trace to debug a failed scrape
- Record a video of a Playwright browser session
- Save and reuse login with storage_state in Playwright
- Read and set cookies in a Playwright context
- Set geolocation and permissions per Playwright context
- Handle HTTP basic auth in Playwright (http_credentials)
- Isolate identities with a browser context per session
- Drag and drop elements in Playwright with drag_to
- When to use an HTTP client vs a real browser
- Migrating from requests + BeautifulSoup to a browser
- Playwright 1.61's WebAuthn Virtual Authenticator
- Playwright 1.62: Headless No Longer Shares the OS Clipboard
- Closed shadow roots: what Playwright cannot see
- Running Playwright Firefox on ARM64 Linux
- What is headless browser automation, and what differs
- Python browser automation without Selenium: the options
- Is Python good for automation? Yes, and here is why
-
AI Agents and Frameworks
- AI browser agents and stealth: what fits and what does not
- browser-use gets detected: what you can and cannot change
- crawl4ai stealth mode and custom browser engines
- Give a LangChain agent an invisible_playwright browser
- Feed invisible_playwright pages into a RAG index
- Computer-use agents and browser fingerprint detection
- Give an MCP browser server a stealth Firefox engine
- Give each AI agent a reproducible browser identity
- Run parallel browser agents with distinct fingerprints
- Why AI browser agents have their own timing signal
- Running an AI browser agent headless on a server
- Give a browser agent a persistent logged-in session
- smolagents: hand the agent an invisible_playwright tool
- Stagehand and stealth: why a Firefox engine won't drop in
- DOM-reading vs screenshot agents: which stealth helps
- Back a computer-use agent with a real browser engine
- AI agent retry loops trip rate limits, not fingerprints
- Playwright 1.62 Ships MCP In the Box
-
Detectors, Explained
- What bot.sannysoft.com actually checks, row by row
- How CreepJS decides you are lying
- What BotD actually detects, and what it does not
- Why a FingerprintJS visitor ID changes
- reCAPTCHA v3 score: why a fresh browser scores badly
- BrowserLeaks canvas and WebGL hash, explained
- What BrowserLeaks actually tests, surface by surface
- Browser trust scores explained: what the number means
- How do websites detect bots?
- What is a browser fingerprint?
- What data does a website collect about your browser?
- Does a VPN stop browser fingerprinting?
- Do websites know you are using a script?
- How accurate is browser fingerprinting?
- Can a website detect a virtual machine?
- Can websites detect a datacenter or proxy IP?
- getClientRects fingerprinting: subpixel geometry as ID
- Notification.permission as a bot-detection signal
- speechSynthesis voices as a cross-platform fingerprint
- Can a website detect typing by keystroke timing?
- Can a website detect Clipboard API access?
- What are mouse-dynamics behavioural biometrics?
- How Cloudflare Turnstile actually works
- How DataDome's bot detection actually works
- How Kasada's bot detection actually works
- PerimeterX (now HUMAN Bot Defender): what the sensor actually checks
- How Akamai Bot Manager actually works
- Imperva (Incapsula), Explained
- F5 Distributed Cloud Bot Defense (Shape), Explained
- Fastly Bot Management, Explained
- reCAPTCHA Enterprise vs reCAPTCHA v3
- Arkose Labs (FunCaptcha), Explained
- AWS WAF Bot Control, Explained
- Anubis: The Proof-of-Work Firewall, Explained
- Cloudflare's AI Labyrinth, Explained
- Beyond robots.txt: How Sites Actually Block AI Crawlers Now
- Vercel Bot Protection (BotID), Explained
- GeeTest v4 (Slide/Click Captcha), Explained
- Honeypot Fields and Hidden Links: How Sites Trap Scrapers
- Private Access Tokens (Privacy Pass), Explained
- hCaptcha, Explained
- hCaptcha Enterprise vs Standard
- Cloudflare Bot Management, Explained
- Queue-it virtual waiting rooms, explained for automation
-
Testing and Troubleshooting
- How to test bot detection without a false pass
- Playwright detected as a bot: the checklist to fix it
- Firefox preferences that silently do nothing
- Slow browser launch: a per-request timeout is not a budget
- Playwright screenshot returns noise: readback fix
- Canvas fingerprint changes every run: use a seed
- Playwright TargetClosedError: the causes and the fixes
- Why am I blocked with a clean fingerprint?
- Why Does My Playwright Script Get Blocked?
- Is Playwright headless detectable? What sites check
- Can You Run Playwright Without Being Detected?
- Why Playwright Works Locally but Fails in the Cloud
- Does Playwright Trigger reCAPTCHA More Often?
- net::ERR_SSL_PROTOCOL_ERROR in Playwright
- net::ERR_CONNECTION_TIMED_OUT in Playwright
- net::ERR_NETWORK_CHANGED in Playwright
- TimeoutError: Timeout 30000ms Exceeded
- 'Playwright "Frame Was Detached" Error'
- Playwright "Protocol Error (Page.navigate)"
- Playwright Strict Mode Violation: Resolved to N Elements
- Playwright "Element Is Not Attached to the DOM"
- Playwright "Subtree Intercepts Pointer Events"
- Content-Security-Policy Blocks Playwright's Injected Scripts
- Playwright "Executable Doesn't Exist" After Install
- 'Playwright "Page Crashed" Error'
- Does Playwright Trigger hCaptcha More Often?
- Keep Playwright Firefox memory flat on long runs
- Playwright Firefox: SEC_ERROR_UNKNOWN_ISSUER
- Playwright ERR_BLOCKED_BY_CLIENT via page.route
- Missing fonts in Docker break Playwright screenshots
- First Firefox launch fails on Windows, then works
- Selenium detected by Cloudflare: the defaults that fail
- Playwright blocked by CORS policy: not bot detection
-
Scraping with Playwright
- How to scrape without getting blocked
- How to scrape a site that blocks headless browsers
- How to scrape infinite scroll pages with Playwright
- How to rotate proxies when scraping with Playwright
- How to scrape data behind a login with Playwright
- How to run Playwright in Docker without getting detected
- How to use invisible_playwright in Docker
- Playwright bot detection: how to avoid it in Python
- How to scrape paginated pages with Playwright
- How to download files with Playwright
- How to upload files with Playwright, and verify it landed
- How to handle cookie consent banners in Playwright
- How to handle popups and modals in Playwright
- How to take full-page screenshots with Playwright
- How to generate a PDF with Playwright and Firefox
- How to wait for content to load in Playwright
- How to retry failed requests when scraping Playwright
- How to scrape pages in parallel with Playwright
- How to rate limit your own Playwright scraper
- How to scrape HTML tables with Playwright
- How to scrape iframe content with Playwright
- How to scrape shadow DOM content with Playwright
- How to capture XHR and API responses in Playwright
- How to scrape geotargeted content with Playwright
- How to scrape real estate listings with Playwright
- How to scrape job postings with Playwright
- How to scrape e-commerce product pages with Playwright
- How to track product prices with Playwright
- How to scrape hotel room prices with Playwright
- How to scrape flight prices with Playwright
- How to scrape classifieds listings with Playwright
- How to scrape vacation rental listings with Playwright
- How to scrape car listings with Playwright
- How to scrape apartment rentals with Playwright
- How to track product stock and restocks with Playwright
- How to scrape location-based store prices with Playwright
- How to scrape flexible-date fare calendars with Playwright
- How to scrape product reviews with Playwright
- How to scrape star ratings with Playwright
- How to scrape news article text with Playwright
- How to scrape business directory listings with Playwright
- How to scrape event and ticket listings with Playwright
- How to scrape restaurant menu data with Playwright
- How to scrape stock and financial data with Playwright
- How to scrape social media profiles with Playwright
- How to scrape forum and community threads with Playwright
- How to scrape image galleries with Playwright
- How to scrape video listings and metadata with Playwright
- Scrape local business results from a map with Playwright
- How to scrape sports stats and box scores with Playwright
- How to scrape cryptocurrency prices with Playwright
- How to scrape deals and coupon codes with Playwright
- How to scrape to CSV with Playwright
- How to scrape to JSON Lines with Playwright
- How to scrape into a SQLite database with Playwright
- How to export scraped data to Excel with Playwright
- How to extract JSON-LD structured data with Playwright
- How to extract Open Graph and meta tags with Playwright
- How to extract links and build a crawl frontier in Playwright
- How to scrape RSS and Atom feeds with Playwright
- How to download images in bulk with Playwright
- How to extract clean article text with Playwright
- How to scrape a sitemap.xml with Playwright
- How to scrape into a pandas DataFrame with Playwright
- How to clean scraped prices and dates with Playwright
- Scrape search results by driving a form in Playwright
- Scrape a map-based search with Playwright
- Scrape autocomplete and typeahead inputs with Playwright
- Scrape date-picker calendars with Playwright
- Crawl list pages to detail pages with Playwright
- Scrape lazy-loaded images with Playwright
- Extract data from canvas charts with Playwright
- Scrape a multi-step wizard flow with Playwright
- How to resume an interrupted scrape with Playwright
- Incremental scraping: only new items since last run
- Handle 403 and 429 backoff mid-scrape in Playwright
- Scrape load-more button pages with Playwright
- Scrape nested pagination with Playwright
- Scrape an SPA that changes URL via history API
- Use BeautifulSoup with invisible_playwright
- Run stealth Playwright tests with pytest fixtures
- Run invisible_playwright concurrently with asyncio
- Run invisible_playwright in GitHub Actions CI
- Can you run invisible_playwright serverless?
- Run invisible_playwright in Celery task workers
- Schedule invisible_playwright scrapes with cron
- Run invisible_playwright headful on a server with Xvfb
- Use invisible_playwright in an Airflow DAG
- Combine invisible_playwright with httpx for speed
- Wrap invisible_playwright in a FastAPI service
- Run invisible_playwright in a Jupyter notebook
- Block images to speed up scraping (and when not to)
- Wait for a specific API response in Playwright
- How to scrape course catalogs with Playwright
- How to scrape store locator pages with Playwright
- How to scrape stock levels with Playwright
- How to scrape accordion and tab content with Playwright
- How to scrape size charts with Playwright
- How to scrape delivery slots with Playwright
- How to scrape appointment availability with Playwright
- How to scrape auction listings with Playwright
- How to scrape public transport timetables with Playwright
- How to scrape GraphQL endpoints with Playwright
- How to scrape virtual scrolling tables with Playwright
- How to scrape shipping rates with Playwright
- How to scrape cursor-based pagination with Playwright
- How to scrape multi-select facet filters with Playwright
- How to scrape currency exchange rates with Playwright
- How to scrape WebSocket streams with Playwright
- How to scrape book metadata with Playwright
- How to scrape professional directories with Playwright
- How to scrape range slider filters with Playwright
- How to scrape currency and locale switchers with Playwright
- How to scrape software changelogs and release notes with Playwright
- How to scrape breadcrumb hierarchies with Playwright
- How to scrape microdata and RDFa markup with Playwright
- How to scrape server-sent events with Playwright
- How to scrape open data portals with Playwright
- How to scrape infinite carousels with Playwright
- How to scrape printer-friendly pages with Playwright
- How to handle A/B test variants when scraping with Playwright
- How to scrape recipe data with Playwright
- How to scrape vehicle recall notices with Playwright
- How to scrape public tender notices with Playwright
- How to scrape nutrition labels with Playwright
- How to scrape podcast episode listings with Playwright
- How to scrape weather station data with Playwright
- How to scrape newsletter archives with Playwright
- How to scrape wine and spirits catalogs with Playwright
- How to scrape insurance quotes with Playwright
- How to scrape fitness class schedules with Playwright
- How to scrape flight seat maps with Playwright
- How to scrape concert and tour dates with Playwright
- How to scrape museum and gallery exhibition dates with Playwright
- How to scrape warranty terms with Playwright
- How to scrape sortable data tables with Playwright
- How to scrape salary and pay scale data with Playwright
- How to scrape live sports scores with Playwright
- How to scrape video game prices with Playwright
- How to scrape domain WHOIS records with Playwright
- How to scrape podcast transcripts with Playwright
- How to scrape patent listings with Playwright
- How to scrape clinical trial listings with Playwright
- How to Handle a PDF That Opens in a New Tab with Playwright
- Does Playwright Support Firefox Extensions?
- Automating an Email OTP / Verification-Link Login with Playwright
- Automating TOTP-Based 2FA Login with Playwright
- How to Scrape a Sandboxed Iframe with Playwright
- Select from dropdowns with Playwright, native and custom
- Download and read PDFs linked from a page with Playwright
- How to scrape parking rates with Playwright
- How to scrape EV charging availability with Playwright
- How to scrape fuel prices with Playwright
- How to scrape ferry schedules with Playwright
- How to scrape library catalog availability with Playwright
- How to scrape package tracking status with Playwright
- How to scrape flight status boards with Playwright
- How to scrape snow reports with Playwright
- How to scrape pet adoption listings with Playwright
- How to scrape construction permit records with Playwright
- How to scrape court docket listings with Playwright
- How to scrape scholarship listings with Playwright
- How to scrape conference agendas with Playwright
- How to scrape package download statistics with Playwright
- How to scrape bank interest rates with Playwright
- How to scrape energy tariff comparisons with Playwright
- How to scrape school term calendars with Playwright
- How to scrape spare part compatibility with Playwright
- How to scrape numbers rendered as images with Playwright
- How to scrape CSS pseudo-element content with Playwright
- Puppeteer scraping examples, and what a real defense does
Comparisons
- Playwright stealth in Python: three levels that work
- Firefox or Chromium for anti-detect automation
- Chromium is not Chrome, and detectors know the difference
- Playwright stealth vs Camoufox: two patched Firefoxes
- Playwright stealth vs Patchright: driver vs engine
- Playwright stealth vs undetected-chromedriver and nodriver
- playwright-stealth vs a patched engine: page vs browser
- puppeteer-extra-plugin-stealth: unmaintained since 2023
- selenium-stealth hasn't been updated since November 2020
- pyppeteer's own maintainer says to switch to Playwright
- invisible_playwright vs rebrowser-patches: the same CDP fix
- invisible_playwright vs fingerprint-suite: injection vs engine
- invisible_playwright vs playwright-with-fingerprints
- invisible_playwright vs Scrapling
- invisible_playwright vs Ulixee Hero
- invisible_playwright vs SeleniumBase UC Mode
- Splash is unmaintained, and it was never a real browser
- invisible_playwright vs DrissionPage
- WebDriver BiDi vs CDP: does the new protocol hide you
- invisible_playwright vs hrequests
- zendriver vs invisible_playwright: Chrome CDP vs Firefox
- botasaurus vs invisible_playwright: framework vs library
- curl_cffi vs invisible_playwright: TLS client vs browser
- pydoll vs invisible_playwright: CDP without a driver
- selenium-driverless vs invisible_playwright stealth
- puppeteer-real-browser vs invisible_playwright
- Migrating from Selenium to Playwright for stealth
- Migrating from Puppeteer to Playwright for stealth
- undetected-chromedriver vs a patched Firefox browser
- scrapy-playwright vs a patched Firefox for stealth
- playwright-extra stealth plugins vs a patched browser
- tls-client vs a real browser: when TLS is enough
- Anti-detect browser or Playwright stealth: which you need
- undetected-playwright vs a patched Firefox binary
- How to Read a Stealth-Browser Benchmark Without Being Misled
- Web Scraping Proxy Costs: Build vs. Buy Your Stealth Stack
- Why Playwright Locators Never Throw StaleElementReferenceException
- invisible_playwright vs browser-use: different jobs
- Selenium vs Playwright: the differences that matter
- Alternative Chromium browsers for automation: what differs
- Browser automation testing tools: where each one fits
Integrations
- Using invisible_playwright with CodeceptJS
- Using invisible_playwright with Crawlee for Python
- Using invisible_playwright with Crawlee for JavaScript
- Using invisible_playwright with scrapy-playwright
- Using invisible_playwright with Robot Framework Browser
- Cypress, WebdriverIO, TestCafe and Nightwatch integration
- Using invisible_playwright with Microsoft's Playwright MCP
- Using the engine from Go, Java, C#, Ruby and Rust
docs/ source folder