Repository navigation
how to scrape course catalogs playwright
To scrape a course catalog with Playwright, treat it as a four-level tree instead of a list of courses: walk department to course to section to meeting time, pin the term in the query string so every request describes the same academic period, read seat counts from the section endpoint instead of the rendered badge, and emit one row per section so a course that runs twice does not collapse into a single record.
A catalog looks like a searchable list and behaves like a database with the joins removed. The page shows courses. What you actually need is sections: the same course taught by two instructors, at two times, with two separate seat counts and two separate waitlists. Scrape the course level and you get a tidy table that answers none of the questions people ask a catalog.
Departments hold courses. A course holds one or more sections. A section holds one or more meeting times, because a lab on Thursday is part of the same section as the lecture on Monday.
A course is the catalog entry: a code, a title, a credit value, a description. A section is one scheduled offering of that course, with its own instructor, room, capacity and enrolment count. A term is the academic period that scopes both, and a cross-listing is a single section reachable under more than one course code.
The row is the section. It is the only level that carries a unique identifier, an instructor, a capacity and an enrolment count. Everything above it is a label and everything below it is a schedule.
Which level answers the question decides which level you store:
| What someone asks the catalog | Level that answers it |
|---|---|
| Does this course exist, and for how many credits? | course |
| Who teaches it and when does it meet? | section |
| Are there seats left? | section |
| Does it clash with my Tuesday lab? | meeting time |
| Which departments own it? | cross-listing |
row = {
"term": "2026-FA",
"department": "CS",
"course_code": "CS 4820",
"course_title": "Introduction to Analysis of Algorithms",
"section_id": "CS-4820-002",
"instructor": "",
"credits": 4,
"capacity": 120,
"enrolled": 118,
"waitlist": 14,
"meetings": [{"days": "MW", "start": "10:10", "end": "11:25", "room": ""}],
}Keeping meetings as a nested list is deliberate. Flattening it into days and time
columns forces you to either drop the lab or duplicate the seat counts, and duplicated
seat counts get summed by whoever reads the file next.
Catalogs default to whatever term the registrar considers current, and that default changes underneath you mid-crawl. A run that starts in the spring term and finishes in the summer term produces a file where two courses that never coexisted appear side by side.
Put the term in the URL and never rely on the session:
page.goto(f"{base}/search?term={term}&subject={dept}", wait_until="domcontentloaded")If the catalog keeps the term in a cookie or a POST body, not the query string, set it once per context and assert it on every response before parsing. The assertion is cheap and the alternative is a silently mixed dataset.
For the general problem of an identity that has to stay constant across a long crawl, see isolate identities with one browser context per session.
The green "Open" pill on the results page is a rendering of a number the page already fetched. It is rounded, it is cached, and on many catalogs it stops updating once the section closes. The underlying call carries the real integers.
Capture the response instead of the pixel:
seats = {}
def on_response(resp):
if "/sections" in resp.url and resp.request.resource_type == "xhr":
for s in resp.json().get("sections", []):
seats[s["id"]] = (s["capacity"], s["enrolled"], s.get("waitlist", 0))
page.on("response", on_response)The mechanics of attaching to the right response, and the failure modes when a page fires several similar calls, are covered in how to capture XHR API responses with Playwright.
Most catalogs collapse sections under the course row and fetch them on click. The sections are not in the initial HTML, so a parse of the loaded document returns courses with zero sections and no error.
Click each course, wait for its own container rather than a timeout, then read:
courses = page.locator("[data-course-id]")
ids = [courses.nth(i).get_attribute("data-course-id")
for i in range(courses.count())] # read ids first, hold no handles
for cid in ids:
page.locator(f"[data-course-id='{cid}']").click() # re-resolved every round
sections = page.locator(f"[data-sections-for='{cid}'] [data-section-id]")
sections.first.wait_for()
for i in range(sections.count()):
rows.append(parse_section(sections.nth(i), cid))Waiting for the container keyed to that specific course matters. A generic wait on
[data-section-id] passes immediately because the previous course's sections are still
in the DOM, and you parse the same section twice under two different course codes.
Holding the element handles from a first pass and clicking them one by one looks equivalent and is not. A catalog that re-renders its course list when a row expands detaches every handle taken before that click, and the loop dies on the second course with a detached-node error. Reading the identifiers first and re-resolving the locator on each round costs one extra query and removes the failure.
The same trap in its general form is described in how to scrape a load-more button with Playwright.
Catalog search pages carry filters for level, credits, days, and delivery mode, and they display a result count. That count is frequently the number of courses while the filter applies to sections, so a filter for "Monday" returns courses that have any Monday section, then shows you all their sections including the Tuesday ones.
Do not use the filters to partition a crawl. Partition by department and term, which are the two dimensions the catalog actually indexes, and filter locally after extraction. The result is slower per request and correct, which is the better trade when the alternative is a file whose row count you cannot explain.
The same section often lists under two departments with two course codes and one shared section identifier. Deduping on course code keeps both. Deduping on section identifier keeps one and silently discards the second department, which is the field somebody wanted.
Keep both rows and mark them:
seen = {}
for r in rows:
key = r["section_id"]
if key in seen:
seen[key]["cross_listed_as"].append(r["course_code"])
else:
r["cross_listed_as"] = []
seen[key] = rA registrar's catalog is a small application in front of a student information system, and the section endpoint is usually the slowest thing it serves. Requesting departments in parallel is what turns a working scraper into a blocked one.
Walk departments sequentially, keep one context for the whole term, and let the natural latency of the section calls set the pace. If a run has to be faster, split it by term across separate days rather than by department across parallel workers.
The reasoning behind rate limits that are set by the target rather than by the client is in how to rate limit your scraper with Playwright, and the retry side is in how to handle 403 and 429 backoff mid-scrape.
Seat counts change; the identity of a section does not. A second run of the same term
should match the first on section_id, course_code and meetings, and differ only on
enrolled and waitlist.
Assert that. If the section identifiers move between runs, the catalog is generating them per session and you need a composite key from term, course code and section number instead. Discovering this on the first run costs one comparison. Discovering it after six weeks of collection costs the collection.
For keeping a long crawl resumable rather than restarting it, see how to resume an interrupted scrape with Playwright.
Course catalogs punish the obvious shape. The list you see is courses, the data you need is sections, and the difference shows up as soon as somebody asks which of two identical course codes still has seats.
Pin the term in the URL. Read capacity and enrolment from the section response rather than the badge. Wait on the container belonging to the course you just clicked. Keep cross-listings as two rows with one shared identifier. Then re-run the term and check that only the seat counts moved.
Should one row be a course or a section? A section. A course with two sections has two instructors, two schedules and two seat counts, and a course-level row cannot hold either pair without duplicating the other.
Why do the seat numbers differ from the page? The badge on the results page is usually a cached rendering that stops updating once a section closes. The section endpoint carries the current integers, so read the response rather than the element.
Why does the filtered result count not match the rows I extract? Catalog filters commonly count courses while returning sections. Partition the crawl by department and term, then filter locally.
Is a cross-listed course a duplicate? No. It is one section reachable under two course codes. Keep one row per section and record the additional codes alongside it.
- Playwright documentation, Events and response handling, retrieved 2026-08-28
- Playwright documentation, Auto-waiting, retrieved 2026-08-28
See also: capturing XHR API responses for reading the section endpoint instead of the badge, scraping a load-more button for the wait that passes on the previous panel, and resuming an interrupted scrape for picking a long term back up.
Written while maintaining invisible_playwright,
a Firefox patched at the C++ level driven by stock Playwright. The generic wait on [data-section-id] is a mistake that shipped here first: it
passes on the previous course's sections and doubles them under a new code.
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
- No public ICE candidate 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 a consistency checker 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
- The canvas and WebGL readback hash, explained
- What a raw-value inspector 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 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