Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Short answer: a headless browser runs browser-engine work without showing a normal window; a headed (often called “real” or visible) browser displays that window. In current Chrome, modern Headless uses the same browser implementation as headed Chrome, so “headless” describes visibility and operating mode—not automatically a different engine. Choose headless for unattended CI, containers, screenshots, PDFs, scraping, and repeatable automation. Choose headed when you need to watch a failure, investigate interactively, or validate behavior that depends on a visible desktop window.
What “headless” and “real browser” mean
Headless browser
A headless browser launches the rendering engine, JavaScript runtime, networking stack, storage, and automation interfaces without displaying the usual graphical user interface. Chrome describes Headless as running “in an unattended environment, without any visible UI.” The process can still create platform windows internally; they simply are not displayed.
Headed (visible) browser
A headed browser is the ordinary desktop-style window. You can see pages load, move the pointer, inspect state, and interact manually while automation runs. “Real browser” is informal wording: a modern headless Chrome session is still Chrome, not a separate website simulator.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallHeadless is not the same as a browser engine
Visibility is one setting. Chromium, Chrome, Firefox, and WebKit remain browser engines or products; an automation library such as Puppeteer, Playwright, or Selenium controls them. A headless flag changes presentation and deployment, not necessarily the standards implementation.
#1 Best Overall
How Chrome Headless changed
Chrome 59 introduced Headless for unattended operation. The original implementation was an alternate browser inside the Chrome binary and could diverge from headed Chrome. Chrome 112 introduced the unified implementation: Chrome creates but does not display platform windows while sharing the regular browser code. Since Chrome 132, the old implementation is available only as the separate chrome-headless-shell binary.
For current Chrome automation, modern Headless shares “the exact same browser implementation as headful Chrome.” That makes it the appropriate default when you need browser-level fidelity, extensions, or end-to-end tests. Do not treat the legacy shell as equivalent: Chrome positions it as a lightweight wrapper for tasks such as screenshotting and scraping, with different dependencies and behavior.
Headless vs. headed: the practical differences
| Decision axis | Headless | Headed / visible |
|---|---|---|
| Interface | No visible UI; suitable for unattended jobs. | Visible platform window for observation and manual interaction. |
| Best environments | CI/CD runners, containers, servers, scheduled jobs. | Developer workstations and interactive diagnosis. |
| Fidelity | Modern Chrome shares the regular implementation; the legacy shell is lighter and differs. | Normal window, desktop integration, and platform behavior. |
| Debugging | Requires logs, traces, screenshots, video, or remote debugging. | You can watch actions and inspect the live page directly. |
| Extensions and browser-level tests | Use modern Headless when high fidelity matters; avoid assuming the legacy shell matches Chrome. | Useful for visible-window and user-facing interaction checks. |
| Resources | The legacy shell is described as lightweight and in some cases more performant for suitable workloads. | Windowing and desktop integration add overhead. |
There is no authoritative universal percentage for headless-versus-headed speed, cost, or reliability. Performance depends on browser build, page content, viewport, fonts, network, video, and the machine. Measure your workload instead of applying a blanket “headless is faster” rule.
When headless is the better choice
Continuous integration and scheduled jobs
CI workers and cron jobs usually have no desktop session. Headless avoids display-server setup and produces deterministic artifacts such as screenshots, traces, and PDFs. Save those artifacts on failure so a non-visual run remains diagnosable.
Containers and remote servers
A server can run browser automation without a monitor or window manager. Pin the browser and automation-library versions, install required fonts, and allocate enough shared memory for your pages.
Capture, PDF, scraping, and data collection
Headless is designed for repeatable navigation, screenshots, PDF generation, network interception, and performance analysis. Respect site terms, authentication boundaries, and robots or access controls; a headless flag does not grant permission to bypass them.
When headed execution is worth the overhead
Interactive debugging
Run headed locally when a selector, popup, redirect, or timing issue is unclear. Watching the page often reveals an overlay, wrong frame, consent dialog, or navigation that logs alone obscure.
Validating visible-window behavior
Test headed when your product depends on window focus, browser chrome integration, display scaling, OS-level dialogs, drag-and-drop, or other desktop effects. Headless cannot prove that a user will see the same window behavior.
Failure reproduction
A useful workflow is to reproduce headed, capture a trace or screenshot, then rerun headless with identical browser, viewport, locale, and data settings in CI.
How automation tools expose the choice
Puppeteer
Puppeteer controls Chrome and Firefox through the Chrome DevTools Protocol and WebDriver BiDi. It supports screenshots, PDFs, navigation, complex UI tests, network interception, and performance analysis. Set the launch option that controls headless mode; use a visible launch during diagnosis.
Playwright
Playwright documents a regular Chromium build for headed operation and a separate Chromium headless shell. Branded Chrome and Edge have moved to a newer Headless implementation closer to regular headed mode, so the selected channel matters. Confirm which browser binary your project actually launches.
Recommended Free Tools
Selenium WebDriver
Selenium can launch Chrome with a --headless argument, or launch the same browser visibly. Keep the rest of the test configuration identical when comparing modes.
DIY: run the same page headless and headed
The following Puppeteer example makes the visibility switch explicit. Install Puppeteer with npm install puppeteer, then save this as capture.mjs.
import puppeteer from 'puppeteer';
const headless = process.argv[2] !== 'headed';
const browser = await puppeteer.launch({ headless });
try {
const page = await browser.newPage();
await page.setViewport({ width: 1440, height: 900, deviceScaleFactor: 1 });
await page.goto('https://example.com', { waitUntil: 'networkidle2', timeout: 90000 });
await page.screenshot({ path: headless ? 'headless.png' : 'headed.png', fullPage: true });
} finally {
await browser.close();
}Run node capture.mjs for Headless or node capture.mjs headed for a visible window. In CI, retain the image and enable tracing or video in your test framework when a failure occurs.
Or skip the browser setup
ScreenshotNeo is a website screenshot API and MCP server. One GET request returns PNG, JPEG, WebP, or PDF without you managing a browser binary:
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo documentation for all options. Equivalent clients:
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);Before capture, ScreenshotNeo accepts cookie or consent banners and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be disabled. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers identify the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients. Every plan includes features such as full-page lazy-image loading, CSS-selector element capture, device presets, custom JavaScript and CSS, request blocking, cookies and headers, PDF controls, caching, signed links, asynchronous webhooks, bulk capture of 100 URLs per call, and a usage API. The Free plan includes 1,000 shots per month with no card; paid plans start at $5 for 3,000 shots. Create a free ScreenshotNeo account.
Reliability, fidelity, and performance checklist
- Match the binary: record browser version, channel, automation-library version, operating system, and launch flags.
- Control the environment: fix viewport, device scale, timezone, locale, geolocation, fonts, color scheme, and test data.
- Wait for the right condition: prefer a selector, network-idle rule, or application-ready signal over an arbitrary sleep.
- Capture evidence: store screenshots, console logs, network logs, traces, and videos for failed headless runs.
- Compare modes fairly: use the same page, credentials, timeout, viewport, and browser build; repeat enough runs to account for network variance.
- Choose the right Headless implementation: modern Chrome Headless for fidelity; the legacy shell only when its lighter footprint and known differences suit the workload.
Troubleshooting common failures
“Browser failed to launch” in CI
Check that the browser binary and dependencies are installed, executable permissions are correct, and the sandbox policy matches your runner. Use the automation library’s supported installation path rather than an unrelated system binary.
Works headed but fails headless
Compare viewport size, device scale, fonts, timezone, locale, permissions, and timing. Add screenshots and a trace at the failure point. An invisible consent dialog, responsive breakpoint, or missing font is often the real difference.
Blank or incomplete screenshots
Wait for a meaningful selector or network-idle condition, then verify lazy-loaded content and scroll behavior. Extend navigation timeouts only after checking DNS, TLS, blocked resources, and application errors.
Selectors time out
Confirm the element is in the correct frame or shadow root, wait for the page state that creates it, and check whether a popup or cookie layer covers it. Do not “fix” a wrong selector by adding an unlimited timeout.
Tests are flaky
Remove race conditions: await navigation and clicks, avoid fixed sleeps where possible, isolate test data, and collect a trace. Re-run in headed mode locally to observe the first divergent action, then fix the synchronization or environment cause.
Decision guide
- Use modern headless for unattended CI, containers, servers, screenshots, PDFs, scraping, and repeatable browser automation.
- Use headed for local diagnosis, exploratory work, and behavior that depends on a visible desktop window.
- Use the legacy headless shell only when its lightweight profile is valuable and you have verified that its browser and dependency differences do not affect your task.
- Switch modes during development: headed to understand a failure, headless to validate the production-like unattended run.
Frequently Asked Questions
Does headless Chrome hide only the window, or does it skip rendering?
Modern Headless still performs normal browser rendering and JavaScript execution; it creates platform windows without displaying them. Output can therefore include the same page pixels, subject to environment differences such as fonts and viewport.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsCan I install browser extensions in Headless?
Use modern Chrome Headless when extension testing is required. Do not assume the separate legacy headless shell has the same extension support or browser behavior.
Should every CI test also run headed?
Not necessarily. Keep the production-like CI run headless, and add a headed diagnostic job or local reproduction path when failures involve visibility, focus, or desktop integration.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
