Screenshot any URL from a real browser in the EU
Enter an address, pick viewport or full page, JPEG or PNG. A fresh browser on EU hardware loads the page, rejects the cookie banner through the consent autopilot, waits for it to settle and returns the image. The API call that produced it is shown beside the result.
Enter a public URL; choose the format, full page or viewport, and a device preset.
This check opens a real browser on our servers and needs JavaScript in yours.
Observations, not verdicts. What you enter is processed for this result and written to a usage journal described in the privacy policy; nothing else is stored.
The screenshot API
One session, one call, one image. The response carries the image as base64 with its width and height, and whether a consent banner was dismissed.
# 1. Open a session
SESSION=$(curl -s -X POST https://browserberg.com/v1/sessions \
-H "Authorization: Bearer $BROWSERBERG_API_KEY" \
-H 'Content-Type: application/json' -d '{}' | jq -r .session.id)
# 2. Take the screenshot (banner rejected first, full page, PNG)
curl -s -X POST https://browserberg.com/v1/sessions/$SESSION/screenshot \
-H "Authorization: Bearer $BROWSERBERG_API_KEY" \
-H 'Content-Type: application/json' \
-d '{ "url": "https://www.example.de/", "format": "png", "fullPage": true, "consent": "reject" }' \
| jq -r .base64 | base64 -d > page.png
# 3. Release the session
curl -s -X DELETE https://browserberg.com/v1/sessions/$SESSION \
-H "Authorization: Bearer $BROWSERBERG_API_KEY"
import { writeFile } from 'node:fs/promises';
import { Browserberg } from '@browserberg/sdk';
const bb = new Browserberg({
apiKey: process.env.BROWSERBERG_API_KEY,
baseUrl: 'https://browserberg.com',
});
await using session = await bb.sessions.create();
const shot = await session.screenshot({
url: 'https://www.example.de/',
format: 'png',
fullPage: true,
consent: 'reject',
});
await writeFile('page.png', Buffer.from(shot.base64, 'base64'));
console.log(shot.width, shot.height, shot.consentDismissed);
from browserberg import Browserberg
bb = Browserberg(api_key="...", base_url="https://browserberg.com")
with bb.sessions.create() as s:
shot = s.screenshot("https://www.example.de/", format="png", full_page=True, consent="reject")
with open("page.png", "wb") as f:
f.write(shot.bytes)
print(shot.width, shot.height, shot.consent_dismissed)
What happens when you press the button
-
A fresh browser opens the page
A container on EU hardware with a clean profile, no cookies from anyone else, and a viewport set to the preset you chose.
-
The banner is answered
The consent autopilot recognises the CMP and presses its reject button, or falls back to a generic deny heuristic. If nothing matched, the banner stays in the picture and the result says consentDismissed: false.
-
The page settles, the picture is taken
After load and an optional extra wait for late-painting pages, the viewport or the whole scroll height is captured as JPEG or PNG.
-
The image and the call are returned
Preview, download, and the exact request that produced it, so the move from the tool to your own code is a copy and paste.
A screenshot API that starts by saying no to the banner
Most screenshot services give you a picture of a cookie banner. The page underneath is what you wanted, and the banner is the first thing any European visitor sees, so a faithful screenshot has to answer it before it looks. Browserberg's sessions carry a consent autopilot that recognises the common consent tools by their own markup, presses the reject button the way a person would, and checks the dialog is gone before the page is read. The screenshot call uses the same mechanism: consent defaults to reject, can be set to accept when you need the page as a consenting visitor sees it, or to off when the banner is what you are documenting.
What you get
A JPEG at a chosen quality or a lossless PNG, of the viewport or of the full scroll height, at the size of the device preset: a desktop width, a tablet, a phone. The response carries the image as base64 with its pixel dimensions, whether it is a full-page capture, whether a banner was dismissed, and how long the whole thing took. A waitMs parameter adds settling time for pages that paint late, up to fifteen seconds.
What it is not
It is not a headless shortcut that renders HTML without a browser: a real Chromium loads the page, runs its scripts and applies its styles, so the picture is what a visitor would see. It is also not a crawler and not a stealth tool; the browser identifies itself honestly, and a site that blocks automated visitors will block this one. The free tool above takes public URLs only. In your own session the same call works after a login, inside a portal, on a page an agent has just navigated to, which is where most screenshot needs actually live: evidence of a submitted form, a dated capture of a price page, a picture of a dashboard for a report.
A full-page capture of a page with infinite scroll captures what had loaded when the picture was taken, not everything the page could ever show. Fixed headers repeat at the top of a full-page image because that is where the browser paints them. Animations are caught mid-frame. None of these are defects to fix; they are what the page did.
Costs and what remains
A screenshot from the tool above is an ordinary metered browser session of a dedicated organisation, capped per visitor and per day. Through the API it is a call on your own session and counts against your browser hours like any other. The URL and the image are returned to you and then discarded; a usage journal keeps the time and the size, as the privacy policy describes. The page you photographed is not stored and not used for anything else.
Parameters of the screenshot call
| url | The page to load; optional in a session that is already on a page |
|---|---|
| format | jpeg (default) or png |
| quality | 1 to 100, JPEG only, default 60 |
| fullPage | false for the viewport (default), true for the whole scroll height |
| consent | reject (default), accept, or off to leave the banner as it is |
| waitMs | Extra settling time after load, 0 to 15000 milliseconds |
| Response | contentType, base64, width, height, fullPage, consentDismissed, durationMs |
As of 2026-09-08
Questions about the screenshot API
How do I take a screenshot of a website by URL?
Enter the URL above and press the button. For automation, the same thing is one POST to the screenshot endpoint of a session, shown in the code samples.
Why is there no cookie banner in the picture?
The consent autopilot rejected it before the capture. If you want the banner in the picture, set consent to off; if you want the page as a consenting visitor sees it, set it to accept.
Can I screenshot a page behind a login?
Not with the free tool. In your own session, log in with a vaulted credential or an agent task first, then call screenshot with no URL to capture the page the session is on.
Where does the browser run?
In a container on hardware in the EU. The image is generated there and returned to you; it is not kept.
How large can a full-page screenshot be?
As tall as the page's scroll height at the chosen width. Very long pages produce very large PNGs; JPEG at the default quality is much smaller and usually enough for evidence.
Is there an MCP tool for this?
Yes, browser_screenshot, on the hosted MCP endpoint. An agent in Claude or another MCP client can take the same picture as part of a task.
Related tools and guides
Take the same picture from inside a login
Five browser hours, no card. Sign in with a vaulted credential and capture the page nobody else can reach.