Best Self-Hosted Screenshot API in 2026

What makes a self-hosted screenshot API worth using?

Before comparing options, it is worth being precise about what “self-hosted screenshot API” means. A bare Puppeteer script is not a screenshot API. A useful self-hosted screenshot API has:

• A REST endpoint — accepts requests over HTTP, not just CLI calls
• Multiple input modes — URL capture, HTML snippet input, and ideally file uploads
• Multiple output formats — PNG at minimum, ideally JPEG, WebP, and PDF
• Docker packaging — reproducible deployment with bundled Chromium
• Concurrency handling — multiple simultaneous screenshot requests without crashes
• Active maintenance — dependency updates, security patches, bug fixes

Most “open-source screenshot APIs” fail one or more of these criteria. Here is the honest state of each option in 2026.

1. Openkova — Best overall

Openkova is an MIT-licensed, self-hostable screenshot API built on Puppeteer and headless Chromium. It is the most complete ready-to-deploy option available in 2026.

• License: MIT — no usage caps, no commercial restrictions, fork freely
• Input modes: HTML snippets, .html file uploads, URL capture, depth-based URL crawling
• Output formats: PNG, JPEG, WebP, PDF
• Streaming: Server-Sent Events (SSE) for real-time progress on batch jobs
• Packages: @openkova/cli (terminal), @openkova/mcp (Claude Desktop, Cursor, Windsurf)
• Docker: Full Docker Compose setup with bundled Chromium — one command to deploy
• Maintenance: Actively maintained as of June 2026
• Cost: Free to self-host. A managed Cloud Pro tier is available for teams that prefer not to manage infrastructure.

The key differentiator versus every other option on this list is the combination of HTML snippet input, SSE streaming, and active maintenance. No other open-source tool has all three.

2. Browserless — Good for CDP use cases, paid at scale

Browserless is a headless browser service built around the Chrome DevTools Protocol (CDP). It is designed for browser automation — running Puppeteer and Playwright scripts remotely — rather than as a purpose-built screenshot API.

• License: Source-available with a commercial license requirement for production use above the free tier
• Input modes: URL only via CDP; no native HTML snippet endpoint
• Docker: Available, but requires a license key for unrestricted use
• Cloud pricing: $25/mo Nano → $80/mo Startup → $200/mo Growth → $350+/mo Scale
• Maintenance: Actively maintained
• Best for: Teams that need full CDP browser control (running arbitrary Puppeteer scripts), not just screenshot conversion

Browserless is genuinely powerful for browser automation. But it is not free at production scale, it does not accept HTML snippet input natively, and its complexity is overkill if you only need screenshots. See the Browserless vs Openkova comparison for a detailed breakdown.

3. Screeenly — Unmaintained since 2020

Screeenly was one of the first open-source screenshot APIs — a Laravel PHP application that wraps PhantomJS and later wkhtmltopdf. It deployed easily and had a simple API.

• License: MIT
• Last meaningful update: 2020
• Rendering engine: wkhtmltopdf — outdated WebKit with no CSS Grid, no custom properties, no modern layout support
• Status: Not recommended for new projects. Security vulnerabilities in dependencies are unpatched.

If you have a legacy Screeenly deployment, migrating to Openkova gives you modern Chromium rendering, HTML snippet input, and an actively maintained codebase with a compatible REST interface.

4. Screenia — Minimal and unmaintained

Screenia is a lightweight PHP screenshot API similar in spirit to Screeenly. It has minimal documentation, a small GitHub star count, and has not received updates in several years.

• License: MIT
• Status: Effectively abandoned
• Input modes: URL only
• Docker: None provided

Not recommended for new projects. No active community, no Docker support, no modern rendering engine.

5. DIY Puppeteer / Playwright server — Maximum control, maximum work

Building your own screenshot API on top of Puppeteer or Playwright is fully viable but requires significant engineering investment. A production-ready implementation needs:

• An HTTP server layer (Express, Fastify, Hono)
• Browser instance pooling and concurrency management
• Input validation and sanitisation
• Error handling and crash recovery for Chromium
• Docker packaging with headless Chromium and all system dependencies
• Ongoing maintenance as Puppeteer/Playwright release breaking changes

Openkova is MIT-licensed open-source — forking it gives you everything above already solved, plus the ability to customise the codebase. Building from scratch rarely makes sense when a well-maintained starting point exists.

Side-by-side comparison

Which should you use?

For most developers and teams in 2026, the decision is straightforward:

• New project, want a self-hosted REST API: Openkova. It is the only actively maintained, MIT-licensed option with full input mode coverage.
• Need full CDP browser control for arbitrary script execution: Browserless. Budget for the licensing cost.
• Have an existing Screeenly or Screenia deployment: Migrate to Openkova. The rendering quality and security posture are significantly better.
• Want maximum customisation and are willing to maintain it: Fork Openkova as your starting point rather than building from scratch.
• Prefer zero infrastructure management: Consider Openkova Cloud Pro (coming soon) or evaluate SaaS options like ScreenshotOne — see the full SaaS vs self-hosted cost breakdown.

Getting started with Openkova

The fastest path to a running self-hosted screenshot API is Docker Compose:

# docker-compose.yml
services:
  openkova:
    image: ghcr.io/scnix-git/openkova:latest
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
    volumes:
      - ./data:/app/data

docker compose up -d

# Take a screenshot
curl -X POST http://localhost:3000/api/screenshot \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com","format":"png"}' \
  --output screenshot.png

For a full walkthrough including HTML snippet input and PDF generation, see the Docker deployment guide.

Frequently asked questions

What is the best self-hosted screenshot API in 2026?

Openkova is the best actively maintained self-hosted screenshot API in 2026. It is MIT-licensed, Docker-deployable, and accepts HTML snippets, file uploads, and URLs — the only open-source option that combines all three input modes with SSE streaming and PDF output.

Is there a free open-source screenshot API?

Yes. Openkova is MIT-licensed and completely free to self-host with no usage caps, no API keys, and no per-screenshot charges. You run it on your own infrastructure using Docker. The only cost is the server you run it on.

Is Browserless free to self-host?

Browserless has a limited free tier but requires a paid commercial license for production use above a low concurrency threshold. The hosted cloud service starts at $25/mo. It is not free in the way MIT-licensed tools like Openkova are.

Is Screeenly still maintained?

No. Screeenly has not received meaningful updates since 2020. Its dependencies are significantly out of date and it uses wkhtmltopdf — an outdated rendering engine that lacks CSS Grid, custom properties, and modern layout support. Openkova is the actively maintained alternative.

Can I build my own screenshot API with Puppeteer?

Yes, but building a production-ready service requires concurrency handling, queuing, error recovery, multiple input formats, Docker packaging, and ongoing maintenance. Openkova already does all of this and is MIT-licensed — forking it is faster than building from scratch.