cutycapt: A tool for capturing screenshots of web pages and converting them to images

I’ve used a lot of screenshot tools over the years, but CutyCapt remains one of my favorites for scripted, headless web page capture — especially in older lab environments or automation pipelines where I don’t want the overhead of a full browser automation framework. It’s a small Qt-based utility (built on WebKit) that renders a URL and saves the result as an image or vector file, entirely from the command line. In this article I’ll cover what it is, how it works, how to install and use it, and where it fits into a modern security or forensics workflow.

What CutyCapt Is and How It Works

CutyCapt is a C++ application that embeds a WebKit rendering engine (via Qt’s QtWebKit module) without displaying an actual browser window. When you give it a URL, it:

1. Loads the page inside an off-screen WebKit widget
2. Waits for the page to finish rendering (with configurable delay/timeout options)
3. Serializes the rendered frame to one of several output formats: PNG, JPEG, BMP, PDF, PS, SVG, or even plain text/HTML dumps

Because it doesn’t need a display server for basic operation in most modern builds (or can use a virtual framebuffer like Xvfb on older ones), it’s ideal for headless servers — something I lean on constantly for automated OSINT and reconnaissance scripts.

Installing CutyCapt

On Debian/Ubuntu/Kali:

sudo apt update
sudo apt install -y cutycapt

If you need to build from source (useful on distros without a package):

sudo apt install -y qtbase5-dev qtwebkit5-dev build-essential
git clone https://github.com/rohanpm/CutyCapt.git
cd CutyCapt
qmake CutyCapt.pro
make

If you’re on a headless server without a display, install a virtual framebuffer:

sudo apt install -y xvfb
Xvfb :99 -screen 0 1280x1024x24 &
export DISPLAY=:99

Basic Syntax

cutycapt --url=<URL> --out=<output_file>

Common flags I use:

cutycapt --url=https://example.com --out=example.png
cutycapt --url=https://example.com --out=example.pdf
cutycapt --url=https://example.com --out=example.png --min-width=1920 --min-height=1080
cutycapt --url=https://example.com --out=example.png --delay=3000
cutycapt --url=https://example.com --out=example.png --user-agent="Mozilla/5.0 CustomAgent"

Example run and expected output:

$ cutycapt --url=https://example.com --out=/tmp/example.png --delay=2000
$ file /tmp/example.png
/tmp/example.png: PNG image data, 1024 x 768, 8-bit/color RGBA, non-interlaced

Real-World Use Cases

Reconnaissance/OSINT during authorized penetration tests — I script CutyCapt to visit a list of subdomains discovered during recon and take a screenshot of each, so I can quickly eyeball which hosts have login portals, default admin pages, or outdated CMS banners without opening dozens of browser tabs manually:

while read -r url; do
  name=$(echo "$url" | sed 's~https\?://~~;s~/~_~g')
  cutycapt --url="$url" --out="screenshots/${name}.png" --delay=2000
done < subdomains.txt

Phishing/incident response evidence capture — during IR work, I’ve used it to render a suspicious URL in an isolated VM and capture visual evidence of a phishing page without a human ever needing to click a live link in a real browser.

Report generation — exporting pages directly to PDF for documentation of findings during a web application assessment.

Integration with Other Tools

• EyeWitness / Aquatone — modern alternatives that wrap similar functionality with reporting; I sometimes use CutyCapt as a lightweight fallback when those tools’ dependencies aren’t available.
• Nmap/Amass output — pipe subdomain enumeration results directly into a CutyCapt loop for mass screenshotting.
• Gowitness — a newer Go-based tool doing the same job with headless Chrome; I still reach for CutyCapt on legacy systems where installing Chromium isn’t practical.

Troubleshooting and Performance

• If pages render blank, increase --delay — JavaScript-heavy sites need more time before the frame is captured.
• On headless servers, forgetting to start Xvfb and export DISPLAY is the single most common failure I’ve hit; you’ll see Qt platform plugin errors.
• CutyCapt’s WebKit engine is old compared to modern Chromium/Firefox — some modern CSS/JS won’t render identically to what a user sees. For accuracy-critical evidence capture, cross-check with a modern headless browser.

Best Practices

• Always set an explicit --min-width/--min-height so screenshots are consistent across a batch job.
• Use --delay deliberately rather than guessing — I usually start at 2000ms and adjust based on the target site’s behavior.
• For any engagement, only capture URLs you’re authorized to test.

FAQ

Is CutyCapt still maintained? It’s a mature, stable utility; development has slowed as headless Chrome/Firefox options have become more popular, but it still works well for lightweight use cases.

Can it capture JavaScript-rendered single-page apps accurately? To a degree — WebKit does execute JS, but very modern frameworks may not render perfectly. Increase delay and test.

Does it need a GUI? No, it can run headlessly with Xvfb or, on some builds, without any display server at all.

Summary

CutyCapt is a lightweight, scriptable way to turn URLs into images or PDFs without the overhead of full browser automation. I still use it for quick recon screenshotting and evidence capture, particularly on older or resource-constrained systems where a full Chromium-based headless browser is overkill.

References

• Official GitHub repository: https://github.com/rohanpm/CutyCapt
• Man page: man cutycapt (available after installation via apt)