A browser your app can drive.
Real Chromium, already running on the platform. Read a page that never shipped an API, capture any URL as an image, or turn your own HTML into a PDF. Nothing to install, nothing to sign up for.
You ask in English. It opens a page.
No browser bundled into your project and no scraping vendor in the middle. Your agent writes a scheduled job that loads the real page, reads what it needs, and mails you the difference.
# runs every morning at 07:00 UTC
[[cron]]
path = "/api/jobs/price-watch"
schedule = "0 7 * * *"
import { browser, email, storage } from 'hatchable';
export const access = 'scheduler';
export default async function (req, res) {
// a real tab: runs the page's JS, then reads the DOM
const rows = await browser.session(async (page) => {
await page.goto('https://supplier.example.com/catalog', {
waitUntil: 'networkidle2',
});
await page.waitForSelector('.sku-row');
return page.$$eval('.sku-row', (els) => els.map((el) => ({
sku: el.querySelector('.sku')?.textContent?.trim(),
price: el.querySelector('.price')?.textContent?.trim(),
})));
});
const changed = await recordAndDiff(rows);
if (!changed.length) return res.json({ changed: 0 });
// png bytes, in memory. storage.put gives them a home.
const png = await browser.screenshot(
'https://supplier.example.com/catalog',
{ width: 1280, height: 900 }
);
await storage.put(`price-watch/${stamp()}.png`, png, 'image/png');
await email.send({
to: 'you@example.com',
subject: `${changed.length} supplier prices moved`,
html: render(changed),
});
res.json({ changed: changed.length });
}
Everything a browser does, from inside your app.
Four calls cover it: fetch a rendered page, capture an image, print a PDF, or take the wheel for a whole flow. The heavy part, a managed Chromium pool, is already running.
Pages that never shipped an API
Open a public page, wait for the part you care about, and pull out the fields you need. For every source that publishes a website and nothing else.
The supplier posts prices in a table. Your app reads them before you wake up.
JavaScript already ran
Plenty of sites send an empty shell and fill it in afterwards, which is why a plain fetch comes back blank. This waits for the page to settle and hands you the finished HTML.
A dashboard that loads its numbers after paint still arrives complete.
Type, click, wait, read
When one page load is not enough, take a session. Fill fields, press buttons, wait for a selector, run code inside the page. Cookies hold for the length of the visit.
Sign in to the portal once, then read the three pages behind it.
Any URL, as an image
Pick a viewport or capture the whole scrolled page, and PNG bytes come back. Point it at a layout you built yourself and you have a share card generator.
Every post gets an Open Graph image the moment it publishes.
Print your own HTML
Build the invoice, the report or the certificate as an ordinary web page, then render it to PDF with the paper size and backgrounds you want. No document library to learn.
The invoice page becomes the PDF attached to the receipt email.
Even the ones behind your sign-in
When the address belongs to your own project, the platform hands the browser a short-lived pass so it renders the real page instead of a login screen. Third-party URLs get nothing.
Capture the members-only report without making it public first.
Nothing to install or wire up
No Chromium in your project, no browser host to rent, no key to paste. If your AI reaches for the library it learned on, the deploy step points it at the browser that is already here.
The import that would have failed becomes the one that works.
A fresh browser every time
Each call runs in its own private browsing context with no cookies, no cache and no history, and it is thrown away when the call ends. Nobody else's visit is in there.
Yesterday's sign-in never leaks into today's capture.
The spec sheet, in plain terms.
browser.html for rendered HTML, browser.screenshot, browser.pdf, and browser.session for a full flow.storage.put and mint a link later. How storage works →Current as of August 2026, read from the browser service and the SDK your projects call. Screenshots and PDFs take no wait-for options: when timing matters, use a session and wait there.
Say it like this.
You never name the tool. These are ordinary asks that turn into a page load, a capture, or a standing morning job.
Asked and answered.
Is this a real browser?
Yes. Headless Chromium, running on the platform. It follows redirects, runs the page's JavaScript, keeps cookies for the length of a session, and renders what a visitor would see.
Do I need to install or sign up for anything?
No. The browser is wired into every project on every plan, including free. There is no API key to paste and no scraping service to subscribe to. If your AI writes code that imports puppeteer, the deploy step redirects it to the built-in browser.
What comes back, a file or a link?
Bytes. A screenshot comes back as PNG data and a PDF as PDF data, held in your function's memory. Saving it is a separate step: store the bytes with a key, then mint a link when you need one. Keep the key rather than the link, because links expire.
Does it work on pages that are empty until JavaScript runs?
Yes, and that is the main reason to use a browser instead of a plain fetch. The page loads, the browser waits for network activity to settle, and you get the finished result rather than an empty shell.
Is scraping allowed?
This is for reading public pages that never shipped an API. Look for an official API first, read the site's terms, respect robots.txt, and keep your request rate polite. Those rules are handed to your AI alongside the code pattern. It is not a tool for getting around a site that has said no.
How long can one run take?
A page load gives up after 30 seconds, and a single call to the browser is capped at 60. A session lasts a minute by default and can be asked for up to four. Long jobs are better split across several scheduled runs than stretched into one.
The method signatures live in the SDK reference, and the plan numbers in the pricing table.
Stop renting a browser.
Connect the AI you already use, say what you want read or captured, and the browser is simply there, warm and waiting.
Want the technical surface? The SDK reference covers browser.html, screenshot, pdf and session.