Screenshot API · 17 output formats

Capture webpages. Skip Chromium ops.

Send a URL, HTML or Markdown in one API call. PageCapture runs the browser and returns an image, PDF, rendered HTML, clean Markdown or video.

Try a live capture no signup Get a free API key

100 successful captures / monthNo card requiredFailures and cache hits cost 0 credits

Prefer to inspect the API first? Read the quickstart.

One API call → the finished filePAGECAPTURE / 01

curl -G https://api.pagecapture.dev/v1/take \
  -H "X-Access-Key: $PAGECAPTURE_KEY" \
  --data-urlencode "url=https://example.com" \
  -d "full_page=true" \
  -d "format=png" \
  -o screenshot.png

Capture result

succeeded

https://example.com

Noma

Shop now

NEW COLLECTION

Objects for slower mornings.

Thoughtful essentials, made in small batches from natural materials.

Explore the collectionOur materials

No. 01 · Hinoki

PLANT-BASEDMADE IN SMALL BATCHESREFILLABLE

Artifact: PNG · 1440×900
Billing: 1 credit
Engine: stable

17formats: Static, document, text and motion outputs through the same API.
144options: Documented and validated, so browser behavior stays in the request.
100MiB: Maximum request body for inline HTML, Markdown and large batches.
1000per batch: Independent items, so one failed page does not fail the entire batch.

The browser is the easy part

Keep Chromium operations out of your application stack.

A local script proves the happy path. Production adds queues, timeouts, fonts, codecs, lazy-loaded content, sticky headers and pages you do not control. PageCapture turns that operational work into one versioned API.

01 / Describe

Send the page and the outcome

Start with a URL, inline HTML or Markdown. Add the viewport, full-page, selector, blocker, authentication and wait options the job needs.

02 / Capture

We operate the browser

Each job runs in an isolated Chromium context, behind queues, timeouts and an egress policy that blocks access to private networks.

03 / Deliver

Receive the file where it belongs

Get raw bytes or JSON in the response, send the artifact to your own S3-compatible bucket, or receive a signed webhook.

Control without browser code

Capture the page you meant to capture. Not merely the page that loaded.

Clean up the page, reproduce the right browser state and choose the output—all with explicit request parameters your team can review and reuse.

Remove what gets in the way

Block ads, cookie banners and chat widgets, or hide the selectors your output does not need.

Capture the intended state

Choose a device, wait for content, click or hover, inject CSS or JavaScript, then take the capture.

Return the right artifact

Use the same integration for images, PDF, rendered HTML, clean Markdown, video and animated GIF.

Grow from one capture to a production pipeline

Switch to async mode and receive a webhook when the file is ready
Verify signed callbacks and deduplicate retries with a stable event id
Send up to 1,000 items while each capture succeeds or fails independently
Reuse captures with an organization-isolated cache and a TTL you control
Handle failures with stable error codes instead of parsing messages

POST /v1/take

{
  "url": "https://example.com/invoice/1042",
  "format": "pdf",
  "async": true,
  "webhook_url": "https://your.app/hooks/capture",
  "webhook_sign": true,
  "external_identifier": "invoice_1042"
}

// 202 Accepted
{ "is_successful": true, "request_id": "req_01...", "status": "accepted" }

How we handle secrets

Your session cookie does its job. Then it disappears.

We keep it only long enough to open the authenticated page. This is its entire lifecycle for every capture, including failed ones.

Read the security model

Secret lifecycle

One capture only

01 / Intake

Encrypted before storage

Separated from the request and sealed with AES-256-GCM before anything is persisted.

02 / In use

Opened inside one browser

Decrypted only in the isolated Chromium worker and injected into that capture.

03 / Job ends

Overwritten, then gone

The encrypted blob is zeroed and the browser context closes, on success or failure.

Logs

Never included

Dashboard

Never displayed

Errors

Never echoed

Billing tied to results

Spend one credit only when a new capture succeeds.

Viewport screenshot, full page, PDF or video: each successful non-cached capture costs one credit. Failures and cache hits cost nothing.

Free

$0/mo

100 credits

Every feature unlocked, capped at 100 successful captures a month.

Basic

$10/mo

2,000 credits

Images, PDF, HTML and Markdown for a single production workload.

Growthmost complete

$47/mo

10,000 credits

Adds scrolling screenshots and video capture.

Scale

$155/mo

50,000 credits

Priority support and the highest limits for heavy pipelines.

Compare every limit

Before you integrate

Questions worth answering before you commit.

Are there official SDKs?

First-party packages for TypeScript, Python, Go, Java, PHP, Ruby and .NET are implemented and tested as release candidates. Public registry promotion is still pending, so the HTTP quickstart remains the installable path today.

What exactly counts as a credit?

One successful capture that was not served from cache. Failures cost nothing — whether the page timed out, the selector was missing, or our infrastructure broke. Cache hits cost nothing either.

Can I capture pages behind a login?

Yes, with cookies, an Authorization header, or custom headers. They are encrypted at rest, decrypted only inside the worker, destroyed when the job ends, and never written to a log.

What stops someone pointing the API at my internal network?

Every URL, redirect, subresource, storage endpoint and webhook target is resolved and checked against blocked ranges — loopback, RFC1918, link-local, CGNAT, cloud metadata services, and the IPv4-mapped IPv6 form of all of them.

How long do you keep my screenshots?

Without caching, the artifact lives minutes for a sync call and up to 24 hours for an async one, then it is deleted. With caching, it lives as long as the TTL you set, isolated to your organization.

Do you store the URLs I capture?

Request logs keep the URL for your plan's retention window so you can debug. Query parameters that look like credentials are redacted. Cookies, headers and keys are never logged at all.

Start with 100 successful captures a month.

Create a free account, copy the request from the playground and get the actual file. No credit card, and failed or cached requests do not spend your allowance.

Get a free API key Try without signing up

Prefer to read first? Every option is documented.