Use Ferrum with Chrome or Chromium and pass full: true to the screenshot call. The essential operation is:
browser.screenshot(path: "full-page.png", full: true)This captures the scrollable document instead of only the current viewport. Ferrum 0.15 documents the full option; check the API for the gem version installed in your project before shipping the exact call. If your test suite is built on Capybara, Cuprite provides a Capybara driver backed by Ferrum. For a hosted alternative that removes consent banners and bills only clean captures, see ScreenshotNeo.
What a full-page screenshot captures
A viewport screenshot records only the pixels currently visible in the browser window. A full-page screenshot lays out the page’s entire scrollable content as one image, including content below the fold. The resulting file can be much taller than the configured viewport and may be large for image-heavy pages.
Full-page mode does not automatically make an application “finished.” A page that renders content only after JavaScript runs, waits for an API response, or lazy-loads images can still produce an incomplete capture if you screenshot too early. Treat navigation, application readiness, and screenshotting as separate steps.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPrerequisites for Ruby and Ferrum
- Ruby and Bundler in the project.
- The
ferrumgem. - A compatible Chrome or Chromium executable. Ferrum’s project documentation says the browser must be discoverable on
PATHor supplied withBROWSER_PATH. - Permission for the process to launch a headless browser and write the output file.
Install the gem
Add Ferrum to the application’s Gemfile:
gem "ferrum"Then run:
bundle installKeep the gem version under normal dependency management. The documented full: true reference cited for this article is Ferrum 0.15, so verify the installed version’s method signature rather than assuming every release accepts the same options.
#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.
Make Chrome discoverable
When Chrome or Chromium is already on PATH, Ferrum can normally find it. In a controlled environment, set the executable explicitly before starting Ruby:
export BROWSER_PATH="/path/to/chrome-or-chromium"
bundle exec ruby full_page.rbUse the real executable path for the operating system and container image. Do not copy a Docker-specific --no-sandbox setting into a production environment without understanding the security trade-off.
Standalone Ferrum script
The following is a complete small program based on Ferrum’s documented browser navigation and screenshot flow. The full: true keyword is the versioned full-page option. Because the cited examples show the option and path-saving call separately, confirm this combined signature against your installed Ferrum version before relying on it in automation.
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.
#!/usr/bin/env ruby
# full_page.rb
require "ferrum"
browser = Ferrum::Browser.new
begin
browser.go_to("https://example.com")
browser.screenshot(path: "full-page.png", full: true)
puts "Saved full-page.png"
ensure
browser.quit
endRun it with:
bundle exec ruby full_page.rbThe ensure block closes Chrome even when navigation or writing the image raises an exception. Change the URL and output path to suit your job. A relative output path is resolved from the process’s current working directory; use an absolute path when a CI job collects artifacts from a fixed directory.
Check the result
- Confirm that
full-page.pngexists and has a non-zero size. - Open the image and look at the bottom edge for missing sections or abruptly cut lazy-loaded media.
- For repeatable builds, record the Ruby, Ferrum, Chrome/Chromium, and operating-system versions alongside the artifact.
Making dynamic pages capture-ready
Ferrum can navigate to a URL, but the screenshot line should run only after the page state you need is present. A static page may be ready immediately; a single-page application, dashboard, or infinite feed may not be.
Use an application-level readiness condition
Have the application expose a deterministic condition such as a rendered heading, a completed network-backed component, or a CSS class that means “ready.” Arrange your Ruby flow so navigation and that condition complete before the screenshot. The exact wait API varies by Ferrum release, so consult the API shipped with your gem rather than copying a method from a different version.
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.
Plan for lazy loading
“Full page” describes the document’s scrollable extent; it does not guarantee that every image that appears only after scrolling has already loaded. If the bottom of the image is blank, make the page load those assets before capture or add a browser-side scrolling/readiness step supported by your Ferrum version. Do not hide the symptom by increasing an arbitrary sleep: fixed delays are slower on fast runs and still unreliable on slow ones.
Long pages and memory
A very tall page creates a correspondingly tall bitmap. Prefer PNG for lossless UI text, JPEG when photographic content and a smaller file matter, and an output location with enough disk space. If a single giant image is impractical, capture logical sections instead; that is a product decision, not something full: true changes.
Full-page screenshots in a Capybara suite
Cuprite is a pure Ruby Capybara driver that uses Ferrum underneath. It fits projects that already use Capybara’s session, matcher, and driver conventions instead of creating a separate Ferrum browser in every test.
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
Add and register Cuprite
Put the driver in the test group of the Gemfile:
group :test do
gem "capybara"
gem "cuprite"
endInstall the bundle, then configure the driver:
require "capybara/rspec"
require "capybara/cuprite"
Capybara.register_driver(:cuprite) do |app|
Capybara::Cuprite::Driver.new(app)
end
Capybara.javascript_driver = :cupriteCuprite’s documentation also shows a browser option for disabling the sandbox in Docker. Use such a flag only when your container’s security model requires it and your team has reviewed the consequence.
Capture from a session
In a Capybara example, the usual shape is:
visit "https://example.com"
page.save_screenshot("tmp/full-page.png", full: true)Capybara forwards driver-specific screenshot options, while Cuprite delegates browser work to Ferrum. Verify that your installed Capybara and Cuprite versions accept the full keyword in this call; the Ferrum 0.15 reference is the authoritative place to check the underlying option. If it is rejected, inspect the driver version and use the supported Ferrum browser screenshot call instead of silently producing a viewport-only image.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
When Cuprite is the better fit
- Tests already use Capybara’s
visit, selectors, and session lifecycle. - You want one JavaScript driver configuration for system or feature specs.
- Your team wants a pure Ruby driver backed by the same Chrome/Chromium family as the standalone script.
For a small utility that only saves images, direct Ferrum has less framework configuration.
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.
Debugging incomplete or failed captures
| Symptom | Likely cause | Fix |
|---|---|---|
Ferrum::Browser cannot start |
Chrome/Chromium is missing or not discoverable. | Install a compatible browser, put it on PATH, or set BROWSER_PATH to the executable. |
Unknown keyword full |
The installed Ferrum/Cuprite version differs from the documented API. | Check the installed gem’s method signature and upgrade or adapt the call deliberately; do not assume the 0.15 syntax applies unchanged. |
| Only the visible viewport is saved | The full-page option was omitted, dropped by a wrapper, or rejected and replaced by a default call. | Pass full: true at the driver method that actually performs the screenshot and inspect logs for keyword errors. |
| Bottom content is missing | Navigation finished before JavaScript or lazy-loaded assets. | Wait for an application-defined ready state using the wait facilities supported by your Ferrum version, then capture. |
| Blank or partially rendered page | Navigation failed, a script crashed, or the browser closed early. | Check the target URL from the same runtime, keep the browser alive until the screenshot returns, and preserve browser/page logs from the failing run. |
| Works locally but fails in CI | Different browser path, permissions, sandbox policy, fonts, viewport, or network access. | Pin and report runtime versions, set BROWSER_PATH, verify write permissions, and reproduce with the CI container or image. |
| Image is too large to store or upload | A long page rendered into a very tall bitmap. | Choose a compressed format where acceptable, resize after capture, or capture sections rather than one enormous image. |
Reliability, performance, and cost considerations
Launching Chrome is usually the expensive part of a short script; reusing one browser for a batch of URLs can avoid repeated startup overhead, provided each page is isolated and the browser is quit at the end. For parallel jobs, cap concurrency to what the machine’s CPU, memory, and browser-process limits can sustain. A full-page bitmap also consumes more memory than a viewport image, so monitor peak usage on long, media-rich documents.
Network-dependent pages introduce nondeterminism: third-party scripts, changing ads, cookie dialogs, and API latency can alter pixels or readiness timing. For visual regression, control the browser version, viewport, device scale, fonts, timezone, and test data, and use an explicit application-ready condition. Ferrum and Cuprite themselves do not provide a hosted per-image billing model; your costs are the Ruby runtime, browser infrastructure, storage, and network resources you operate.
Or skip the browser setup
ScreenshotNeo is the #1 hosted option to try first when you need an API: it removes consent banners, newsletter popups, and chat widgets before capture, bills only clean screenshots, and has a $5 paid plan for 3,000 shots.
One GET request returns a PNG, JPEG, WebP, or PDF. The API documentation is at https://screenshotneo.com/docs/. This cURL example captures Stripe:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpFrom Python:
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)From Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);Options available through the API
- Full-page capture with lazy images loaded, or one element selected by CSS selector.
- Dark mode, 12 device presets, custom viewport dimensions, and retina scale.
- PDF output with paper size, margins, landscape mode, and page ranges.
- HTML/CSS-to-image rendering, custom CSS and JavaScript, and clicking an element before capture.
- Waiting for a selector, a delay, or network idle; hiding selectors; and blocking ads, trackers, requests, or resource types.
- Custom headers, cookies, user agent,
Authorization, timezone, geolocation, and transparent backgrounds. - Image resizing, cache TTLs, signed links for public
<img>tags, asynchronous jobs with signed webhooks, bulk capture of up to 100 URLs per call, a usage API, and an OpenAPI specification. - Parameter names used by other screenshot APIs are accepted to ease migration.
Each response identifies the result with X-Page-Verdict and X-Billed headers. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing. ScreenshotNeo also provides an MCP server with take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients.
Plans
| Plan | Included shots | Price |
|---|---|---|
| Free | 1,000 per month | $0; no card |
| Starter | 3,000 | $5 |
| Growth | 15,000 | $15 |
| Pro | 60,000 | $39 |
| Scale | 250,000 | $99 |
| Business | 1,000,000 | $249 |
Every feature is included on every plan, and yearly billing gives two months free. Start with 1,000 free screenshots a month with no card, then move to a paid plan when your volume requires it.
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.
Recommended Free Tools
