HEADLESS BROWSER • Stateless JS Rendering

Render any page. One call, fresh browser.

Send a URL, get the page as a real browser sees it — hydrated HTML, markdown, the result of your own JavaScript, or a screenshot. Click, type, and scroll before capture. Every call is a fresh browser and nothing is kept between calls — not a server farm you have to run.

Need click, type, and scroll steps across many URLs? See browser automation. Just need one page fetched? Use the scraping API.

CORE CAPABILITIES

The headless browser primitive, without the server fleet.

STATELESS

Every call is a fresh browser

Each request starts a clean headless browser, does its work, and throws the browser away. Cookies, localStorage, and cache are not kept between calls, so there is nothing to open, keep alive, or clean up — and no state leaking from one request into the next.

STEALTH

Stealth and fallback built in

Scrape calls run in stealth mode by default, and you can opt into captcha solving with solve_captcha. Renders that get blocked escalate through fallback tiers automatically, and the response tells you which tier served it in tier_used.

FIDELITY

Render JavaScript, get clean HTML

Point the API at a URL and it executes the page's JavaScript, waits for load or network idle, and returns rendered HTML, markdown, text, or links. Evaluate your own JavaScript expression in the page with js_eval and get the value back in eval_result.

ZERO OPS

No browser farm to run

No idle Chromium pool, no autoscaling to tune, no out-of-memory crashes at 3 a.m. Send a request, get the page back. Render and scrape cost 1 credit each (JavaScript rendering adds nothing), screenshots cost 3, and failed calls are refunded.

BROWSER SURFACE

Render, evaluate, act, capture.

Four independent calls, one bearer token. Each starts a fresh browser; nothing carries over to the next.

Render a page
# Render a URL in a fresh headless browser. JavaScript runs; you get the hydrated HTML.
curl -X POST https://api.ollagraph.com/v1/render \
  -H "Authorization: Bearer $OLLAGRAPH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/app"}'
# => { "status": "success", "url": "...", "final_url": "...",
#      "html": "<!doctype html>...", "tier_used": "...", "status_code": 200 }
Wait & evaluate JS
# Wait for the network to settle, return markdown, and evaluate a JS expression.
curl -X POST https://api.ollagraph.com/v1/scrape \
  -H "Authorization: Bearer $OLLAGRAPH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/dashboard",
    "wait_until": "networkidle0",
    "format": "markdown",
    "js_eval": "document.querySelectorAll(\"article\").length"
  }'
# => { "status": "success", "url": "...", "format": "markdown", "content": "...",
#      "eval_result": "24", "time_ms": 2310, "fallback": false }
Run page actions
# Run page actions on the loaded page before it is captured — click, type, scroll.
curl -X POST https://api.ollagraph.com/v1/scrape \
  -H "Authorization: Bearer $OLLAGRAPH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/reports",
    "format": "html",
    "actions": [
      {"action": "type", "selector": "input[name=filter]", "text": "2026"},
      {"action": "click", "selector": "#load-report"},
      {"action": "scroll_to_bottom"}
    ]
  }'
# Actions run once, in order, then the page is captured. They don't wait for a
# navigation, so use them for in-page interactions, not multi-page flows.
Capture a screenshot
# Capture a full-page screenshot. Raw PNG bytes by default.
curl -X POST https://api.ollagraph.com/v1/screenshot \
  -H "Authorization: Bearer $OLLAGRAPH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/dashboard",
    "full_page": true,
    "wait_until": "networkidle0",
    "device_scale_factor": 2
  }' -o dashboard.png
# Pass "output": "json" instead to get
# { "status", "url", "final_url", "content_type", "bytes", "image_base64" }

Part of the full 123-endpoint surface. For one-shot fetches see scraping, for whole-site sweeps see crawling, and for page actions at scale see automation.

FREQUENTLY ASKED QUESTIONS

Headless browser questions

1

How is the browser surface different from the scraping API?

They run on the same stateless headless browser. POST /v1/render returns the raw post-hydration HTML and the final URL. POST /v1/scrape adds output formats (markdown, html, text, links), wait_until, js_eval, page actions, and captcha solving. POST /v1/screenshot returns an image of the rendered page. Pick whichever output you need — each one is a single call.
2

How is this different from browser automation?

The automation page covers the same browser driven with page actions — click, type, and scroll steps sent as JSON — and how to run them across many URLs with batch and async jobs. There is no natural-language agent: you describe the steps explicitly, and every call is still a fresh browser.
3

Which endpoints make up the browser surface?

Three. POST /v1/render loads a URL, executes its JavaScript, and returns the hydrated HTML. POST /v1/scrape renders a URL and returns content in the format you choose, with wait_until, js_eval, actions (click, type, scroll_to_bottom), stealth, timeout, proxy, user_agent, and solve_captcha. POST /v1/screenshot captures the page as PNG or JPEG, full-page or element-scoped. For many URLs, use /v1/scrape/batch, /v1/scrape/async, or /v1/crawl.
4

How is it billed?

Render and scrape cost 1 credit per call, and JavaScript rendering adds nothing. Screenshots cost 3 credits. Opting into a residential proxy adds 3 credits. Failed calls are refunded, so a render that times out costs you nothing. You get 1,000 free credits on signup — see the pricing page for current packs.
5

Is any state kept between calls?

No. Every call starts a fresh browser with no cookies, storage, or cache from any earlier call, yours or anyone else's, and that browser is discarded when the call ends. Nothing scraped is persisted on our side beyond the response we hand back. If your flow needs state across page loads, run that part in your own browser tooling.
6

What page actions are supported?

Three, sent as a JSON array on POST /v1/scrape: {"action": "click", "selector": ...}, {"action": "type", "selector": ..., "text": ...}, and {"action": "scroll_to_bottom"}. The key is action. Up to 50 actions run once, in order, on the loaded page before it is captured. There is no wait action — use wait_until to control when the page counts as loaded.
7

What about pages behind a login?

Not supported. Actions run on a single loaded page and do not wait for a navigation, so they cannot complete a login form, and no cookies or session carry from one call to the next. You also cannot send your own cookies or custom request headers (only a user_agent override). Use the API for publicly reachable pages.
8

Can I run a multi-step interaction across several calls?

Not as one continuous browser — each call is independent. Put in-page steps (open a panel, type into a filter, load more, scroll) in the actions array of a single scrape call. For flows that need state across page loads, drive your own browser with an open-source tool like Playwright and use Ollagraph for the stateless fetches around it.
1,000 free credits • Failed calls refunded

Render your first page in five minutes.

1,000 free credits, one bearer token, no browser to run, failed calls auto-refund.

No credit card required Managed headless browser 123 endpoints live