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 errorsFor a headless Go application using chromedp, the simplest supported starting point is the project-maintained chromedp/headless-shell Docker image. Its bundled browser is discoverable by chromedp, so you can run your Go program in the image without separately installing Chrome or configuring a browser path. The main operational choices are selecting a repeatable image tag, ensuring the browser endpoint is reachable if you run Chrome separately, and allocating enough shared memory for your workload. chromedp’s README describes this as the simplest way to run chromedp in a headless environment.
Choose the right Headless Shell
There are two related but distinct ways to get a headless Chrome browser. The chromedp-maintained docker.io/chromedp/headless-shell image packages headless-shell in a container and is set up for chromedp to find it. The image is also intended for other applications that speak the Chrome DevTools Protocol (CDP). For the standard chromedp-in-Docker case, start with this image rather than assembling a browser installation yourself. See the image README for its current tags and instructions.
Do not confuse that container image with the separately distributed Chrome for Testing binary called chrome-headless-shell. Chromium’s headless documentation says precompiled headless-shell binaries have been available through Chrome for Testing since M118. It also says that, from M132, the old headless functionality is no longer part of the Chrome binary, and --headless=old has no effect; users who need old Headless should migrate to chrome-headless-shell. Those are Chromium release notes, not a description of the chromedp image’s own tags or packaging. See Chromium’s headless documentation.
Select and pin an image tag
The image README documents stable, beta, and dev channel tags as well as version-specific tags. A channel tag follows its release channel and can point to a different browser build over time. Pin a version-specific tag when you need repeatable builds—for example, in CI, release builds, or a deployment where browser changes should be deliberate. Recheck the project README or image registry for currently available tags before using a particular one; tag availability and the channel’s current version can change.
#1 Best Overall
- Read Before You Buy — No Video Output: These adapters support charging and USB 2.0 data transfer, but cannot transmit video signals. Except for standard USB webcams (which use USB data only), they are not compatible with HDMI/DisplayPort cables, video-capable USB-C hubs, or docking stations with video output.
- Convert USB-A Ports to USB-C: Designed to connect USB-C earphones, cables, flash drives, card readers, and other USB-C accessories to standard USB-A ports. Plug-and-play with no drivers or software required.
- Aluminum Alloy Housing: Built with a sturdy aluminum alloy shell that aids in heat dissipation and protects against daily wear and scratches. Designed to maintain a stable and secure connection.
- Compact & Travel-Friendly: The ultra-compact design allows the adapter to stay plugged into your device without blocking adjacent ports or adding bulk, reducing wear and tear on your original USB ports.
- 12-Month Warranty: Backed by a 12-month manufacturer warranty for peace of mind. Designed to meet strict quality control standards for reliable everyday performance.
For a quick local trial, pull the floating stable tag shown in the README:
docker pull chromedp/headless-shell:latestFor a repeatable build, substitute a currently listed version-specific tag:
docker pull chromedp/headless-shell:<version-tag-from-the-project-README>Replace the example placeholder with a real tag from the README; it is not a literal Docker tag. Pinning the image tag controls which packaged browser build you start from, while your Go module version is controlled separately by your project’s dependency files. Keep both choices visible in your build and update them intentionally.
Run the Go program inside the image
The project’s recommended arrangement is to run the Go program that uses chromedp inside the chromedp/headless-shell image. The image includes the browser, which chromedp can find out of the box. This avoids the separate-browser network wiring needed when Chrome runs in another container.
Rank #2
- 5-in-1 USB-C Hub: Experience comprehensive connectivity featuring a Power Delivery input, two USB-A 2.0 ports, a USB-A 3.0 port, and an HDMI port. (Note: The USB-C power delivery input port is only for connecting an external wall charger to power your laptop and cannot power peripheral devices.)
- 90W Pass-Through Charging: Achieve optimal charging with 90W pass-through power to your laptop, supported by a total input of 100W, with the hub reserving 10W for operational efficiency. (Note: Wall charger not included.)
- Quick Data Transfers: Accelerate your productivity with rapid data transfers using a high-speed 5Gbps USB 3.0 port and two 480Mbps USB 2.0 ports.
- 4K HDMI Display: Enhance your visual experience with a hub capable of delivering 4K resolution at 30Hz in both mirror and extend modes. Please note that this hub is compatible with MacBook (macOS 12 and newer), Windows 10 and 11, ChromeOS, and laptops equipped with DP Alt Mode and Power Delivery. Note: This device is not compatible with Linux.
- What You Get: Anker USB-C Hub (5-in-1, 4K HDMI), welcome guide, 18-month warranty, and our friendly customer service.
A minimal Docker run using the project image looks like this:
docker run --rm chromedp/headless-shell:latestThe image README also shows publishing port 9222, the usual remote-debugging port, when the browser needs to accept a CDP connection from outside its container:
docker run --rm -p 9222:9222 chromedp/headless-shell:latestPublishing a port does not by itself make a Go process connect to that browser. Your application must be configured with a browser endpoint that it can reach, and the browser must be started with the corresponding remote-debugging configuration. The exact container command and application endpoint depend on whether the app and browser share a container, share a Docker network, or run on different hosts. Avoid exposing a debugging endpoint to an untrusted network: CDP access can control the browser.
When the app and browser run separately
If you need a long-running Chrome instance separate from your Go process, chromedp documents connecting to a manually started browser with a RemoteAllocator. In that arrangement, ensure that the browser’s debugging endpoint is reachable from the Go process using the container or host networking you have chosen. Do not assume that localhost inside one container refers to another container; use the reachable service name or address on the shared network, and restrict access to the debugging port.
Rank #3
- Sleek 7-in-1 USB-C Hub: Features an HDMI port, two USB-A 3.0 ports, and a USB-C data port, each providing 5Gbps transfer speeds. It also includes a USB-C PD input port for charging up to 100W and dual SD and TF card slots, all in a compact design.
- Flawless 4K@60Hz Video with HDMI: Delivers exceptional clarity and smoothness with its 4K@60Hz HDMI port, making it ideal for high-definition presentations and entertainment. (Note: Only the HDMI port supports video projection; the USB-C port is for data transfer only.)
- Double Up on Efficiency: The two USB-A 3.0 ports and a USB-C port support a fast 5Gbps data rate, significantly boosting your transfer speeds and improving productivity.
- Fast and Reliable 85W Charging: Offers high-capacity, speedy charging for laptops up to 85W, so you spend less time tethered to an outlet and more time being productive.
- What You Get: Anker USB-C Hub (7-in-1), welcome guide, 18-month warranty, and our friendly customer service.
Build a container for your Go application
For a deployable service, put the application and browser in the same image or otherwise arrange for your application to run in the maintained image. The README’s principle is that chromedp can discover the bundled browser; there is no requirement to download another Chrome executable in the application container for that basic setup. A project-specific Dockerfile must still account for your Go build, application files, startup command, and runtime permissions. The chromedp image examples should be adapted to your own app rather than treated as a complete application Dockerfile.
When adapting the maintained image’s security example, note that its README demonstrates an unprivileged nobody user, a Chrome seccomp profile, and explicit entrypoint and flags. These are example settings, not a universal security profile. Check that any seccomp policy and browser flags are appropriate for your host’s Docker and security configuration. Do not copy a profile blindly or run the browser with more privileges than your workload needs.
Handle shared memory and process cleanup
Increase shared memory for the documented BUS_ADRERR case
If the container exits or Chrome crashes with BUS_ADRERR, the image README suggests increasing shared memory with Docker’s --shm-size option:
docker run --rm --shm-size 2G chromedp/headless-shell:latestThis is a documented remedy for that failure mode, not proof that every browser crash is caused by shared-memory limits. If the symptom continues, inspect the container logs and host resource limits as well as the browser’s own startup output.
Free tools Windows power users keep installed
One-click scans. No signup required.
Rank #4
- Dual Converters, Infinite Potential：Includes 2× USB C male to USB A female adapters and 2× USB A male to USB C female adapters. Perfect for a wide range of uses—tablets with Bluetooth keyboards, expand USB ports on macbook, and more. Two different converters for all your daily needs
- Next-Level 10Gbps & 3A Charging: No more slow 480Mbps, this usb to usb c adapter has a transfer speed of up to 10Gbps, allowing you to do more transferring in less time. This usb adapter fits both USB A and USB C charger, supporting up to 3A fast charging
- Upgraded Exquisite Craftsmanship: With an aluminum alloy housing and metal connector, the usbc to usb adapter is extremely durable and sturdy. Rigorously tested to withstand more than 10,000 times of plugging and unplugging, ensuring long-lasting performance
- Broad Compatible: The usb c to usb adapter widely supports all USB C/ USB A devices like laptops, tablets, cellphones, car chargers, and phone chargers. Such as compatible with MacBook Pro/Air 2023/2022, Thunderbolt 4/3 Devices,Apple MagSafe Watch 9/8/7/SE/Ultra, iPad Pro 2022/2021, Samsung Galaxy S23/S20/S10, and iPhone 17/16/15 Pro. Plug and play
- Please Note: To reach 10Gbps speed, keep the cable under 3.3 ft. For USB A Male to USB C adapters, try flipping the USB C connector. USB C Male to USB A adapters support bidirectional 10Gbps transfer within 3.3 ft
Use an init process to reap child processes
The maintainers recommend Docker’s --init option to reap zombie processes created by child processes:
docker run --rm --init chromedp/headless-shell:latestFor Docker versions older than 1.13.0, the image README suggests using dumb-init or tini as the container entrypoint instead. Use the method that matches the Docker version and startup configuration on your host.
When to supply a different Chrome-compatible executable
You can run chromedp against another Chrome-compatible executable, including a Chrome for Testing headless-shell binary, but then you take responsibility for obtaining the binary, keeping its version aligned with your intended browser release, making it executable, and ensuring chromedp can launch or connect to it. The maintained image is simpler for the ordinary headless case because the browser is bundled and discoverable. No official source cited here establishes a performance or image-size advantage for either approach, so choose based on packaging, version control, and operational needs rather than an assumed benchmark.
| Choice | Browser present and discoverable | Version control | Runtime responsibility |
|---|---|---|---|
| chromedp-maintained image | Bundled; chromedp can find it out of the box, according to the project documentation. | Choose a channel tag or a version-specific tag; channel tags move. | Configure container networking when connecting remotely; tune shared memory and process cleanup as needed. |
| Separately supplied compatible executable | You supply and configure the executable or start a browser for remote CDP access. | You select and maintain the executable version; the cited documentation does not prescribe a universal pairing policy. | You configure browser startup, endpoint reachability, shared memory, and process cleanup in your own runtime. |
Troubleshoot common container problems
- chromedp cannot find or launch the browser: Confirm that the process is running in the maintained image and that you have not replaced its browser packaging or startup behavior. If using another executable, verify its path, permissions, and launch configuration.
- The Go process cannot connect to the browser: Check that the browser was started to accept CDP connections, that the debugging port is exposed or reachable on the relevant Docker network, and that the endpoint used by the application is the browser’s reachable address—not an unrelated container’s
localhost. - Chrome exits with
BUS_ADRERR: Try the README’s documented--shm-size 2Gsetting, then check logs and other resource limits if the crash persists. - Zombie browser processes accumulate: Run the container with
--init, or usedumb-initortinias appropriate for an older Docker installation. - A browser update changes behavior: If you were using a floating channel tag, check which image version is now being pulled. Pin a currently available version-specific tag for reproducible builds and update it as a deliberate change.
- A hardened container fails to start Chrome: Review your user, seccomp profile, entrypoint, and flags against the host’s security policy. The README’s security example is a starting point to adapt, not a guarantee for every environment.
Or skip the browser setup
If your goal is to capture website screenshots rather than operate your own browser container, ScreenshotNeo offers a screenshot API and MCP server. A GET request can return a PNG, JPEG, WebP, or PDF. Its optional cleanup accepts cookie or consent banners and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each of those steps can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, with the outcome identified in response headers. Its MCP tools include take_screenshot, get_page_info, and capture_pdf, so compatible AI clients can request captures without you managing Chrome in a container.
Recommended Free Tools
For a one-call screenshot, replace the URL and API key with your target and credentials. See the ScreenshotNeo API documentation for request options and response details.
Best Value
- 5-in-1 Connectivity: Equipped with a 4K HDMI port, a 5 Gbps USB-C data port, two 5 Gbps USB-A ports, and a USB C 100W PD-IN port. Note: The USB C 100W PD-IN port supports only charging and does not support data transfer devices such as headphones or speakers.
- Powerful Pass-Through Charging: Supports up to 85W pass-through charging so you can power up your laptop while you use the hub. Note: Pass-through charging requires a charger (not included). Note: To achieve full power for iPad, we recommend using a 45W wall charger.
- Transfer Files in Seconds: Move files to and from your laptop at speeds of up to 5 Gbps via the USB-C and USB-A data ports. Note: The USB C 5Gbps Data port does not support video output.
- HD Display: Connect to the HDMI port to stream or mirror content to an external monitor in resolutions of up to 4K@30Hz. Note: The USB-C ports do not support video output.
- What You Get: Anker 332 USB-C Hub (5-in-1), welcome guide, our worry-free 18-month warranty, and friendly customer service.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpThe free plan includes 1,000 screenshots per month without a card; paid plans start at $5 for 3,000 screenshots. Sign up for ScreenshotNeo’s free plan to try a capture without setting up a browser container.
Frequently Asked Questions
Can chromedp run in a headless environment?
Yes. The chromedp project recommends running the Go program inside its headless-shell image for the simplest headless setup.
Is Chrome Headless Shell the same thing as Chrome’s –headless=old mode?
They are related but not interchangeable labels. Chromium says old headless functionality left the Chrome binary from M132 and directs users who need it to chrome-headless-shell; the chromedp image is its own separately maintained container packaging.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →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.
