The Browserbase alternative that renders in one call

Browserbase has a one-call path — the Fetch API — but it never executes JavaScript, and it cannot return a screenshot or a PDF. Anything rendered means opening a browser session and paying by the browser-hour. Microlink renders every request in a real browser and returns the finished artifact from a single call.

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://vercel.com' URL with 'screenshot' & 'data' API parameters:

CLI Microlink API example

microlink https://vercel.com&screenshot&data.markdown.attr=markdown

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://vercel.com" \
  -d "screenshot=true" \
  -d "data.markdown.attr=markdown"

JavaScript Microlink API example

import createClient from 'microlink.io'

const microlink = createClient()

const data = await microlink.screenshot('https://vercel.com', {
  data: {
    markdown: {
      attr: "markdown"
    }
  }
})

Python Microlink API example

import requests

url = "https://api.microlink.io/"

querystring = {
    "url": "https://vercel.com",
    "screenshot": "true",
    "data.markdown.attr": "markdown"
}

response = requests.get(url, params=querystring)

print(response.json())

Ruby Microlink API example

require 'uri'
require 'net/http'

base_url = "https://api.microlink.io/"

params = {
  url: "https://vercel.com",
  screenshot: "true",
  data.markdown.attr: "markdown"
}

uri = URI(base_url)
uri.query = URI.encode_www_form(params)

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
response = http.request(request)

puts response.body

PHP Microlink API example

<?php

$baseUrl = "https://api.microlink.io/";

$params = [
    "url" => "https://vercel.com",
    "screenshot" => "true",
    "data.markdown.attr" => "markdown"
];

$query = http_build_query($params);
$url = $baseUrl . '?' . $query;

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET"
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
    echo "cURL Error #: " . $err;
} else {
    echo $response;
}

Golang Microlink API example

package main

import (
    "fmt"
    "net/http"
    "net/url"
    "io"
)

func main() {
    baseURL := "https://api.microlink.io"

    u, err := url.Parse(baseURL)
    if err != nil {
        panic(err)
    }
    q := u.Query()
    q.Set("url", "https://vercel.com")
    q.Set("screenshot", "true")
    q.Set("data.markdown.attr", "markdown")
    u.RawQuery = q.Encode()

    req, err := http.NewRequest("GET", u.String(), nil)
    if err != nil {
        panic(err)
    }

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

import createClient from 'microlink.io'

const microlink = createClient()

const data = await microlink.screenshot('https://vercel.com', {
  data: {
    markdown: {
      attr: "markdown"
    }
  }
})

One call. Rendered, not fetched.

Every Microlink request boots a real browser, runs the page, and returns the finished artifact. There is no cheaper tier that quietly skips JavaScript, and no session to open when the page turns out to need one.

JavaScript always runs
Client-rendered apps, lazy-loaded content, and hydration are handled the same way on every request. Nothing degrades to a plain HTTP fetch behind your back.
Pick the output, not the pipeline
Ask for Markdown, HTML, metadata, a screenshot, a PDF, or a custom data shape with CSS selectors — several of them in the same request.
Run code when you need to
Browser Functions execute your JavaScript against a live Puppeteer page and require() any npm package — page-level control without operating a session.
Blocked targets are named
Antibot detection tells you which of 30+ providers refused the request on every plan, and residential proxy resolution reroutes it on Pro.
Made for AI agents
The Microlink MCP server gives an agent 20 web tools in natural language — screenshot, PDF, Markdown, extract, and more — that return results instead of browser state.
Isolated and cacheable
Every call runs in one ephemeral browser behind an SSRF gate. Set a ttl and repeat requests come back from the edge without booting a browser at all.

What it takes to get the result.

Browserbase splits the work across a fetcher, a browser session, and a search index, each metered separately. On Microlink every row below is the same endpoint and the same unit — one request.

What you want	On Browserbase	On Microlink
Raw HTML of a static page	Fetch API — from $0.50 per 1,000 calls, no JavaScript run	html — rendered, one request
Markdown of a static page	Fetch Extract — $4 per 1,000 calls	markdown — one request
Markdown of a client-rendered app	Out of scope for Fetch — open a session, pay browser-hours	The same one request
A screenshot	A session you drive: connect Playwright or CDP and capture	screenshot — a parameter on the call
A PDF	A session you drive — Fetch cannot produce or convert PDFs	pdf — a parameter on the call
Structured fields from a rendered page	Fetch Extract with a schema, but without JavaScript	data with CSS selectors, after rendering
Google results as JSON	Search API — $7 per 1,000 calls past the included quota	search — a request like any other, on paid plans

Fetch limits and pricing are Browserbase's own, published in the Fetch overview — “Fetch doesn't execute JavaScript and has a 5 MB content limit” — and on browserbase.com/pricing, read August 2026. Per-call rates shown are Startup-plan overages; the Developer plan is $1 per 1,000 Fetch calls.

Send the URL Get the rendered result back

2.8

secs

P95 screenshot

2.0

secs

P95 metadata

99.9

SLA Guaranteed

Start free, scale when ready

No browser-hours, no concurrency tier, no proxy GB, no separate meter for fetching and searching. One request is one API call — under €1 per 1,000 requests on the entry Pro plan, and 25 a day free with no credit card.

Free

Try the API in seconds. No card.

$0/month

25 requests per day

Get started free

Pro

For production workloads.

$49/month

≈ $1.07 per 1,000 requests

46,000 requests / month

Cancel anytime · No setup fees

Enterprise

Dedicated infra for high-volume.

Custom

Tailored to your volume

Explore Enterprise

Need more details?

Compare every plan side by side

Start now

Point a URL at the API and get the rendered result back — screenshot, PDF, Markdown, or structured data. 25 requests a day, no account, no browser to operate.

Get started free

No login needed

25 reqs/day free

No credit card

Capability by capability, side by side.

Both platforms put a real browser behind an API. What differs is how much of the work you still do, what a call costs, and what ships in the box. Every Browserbase row comes from their documentation, Fetch reference and pricing page, including the last four, where Browserbase has capabilities Microlink does not.

Capability	Microlink	Browserbase
Billing unit Browserbase meters browser-hours, concurrency tier, proxy GB, Fetch calls, Search calls and agent runs. A Microlink request costs the same whatever it returns.	1 request	6 meters
JavaScript on the one-call path Browserbase Fetch “doesn’t execute JavaScript and has a 5 MB content limit”. Rendering means opening a session. Every Microlink request renders.	✓	✕
Screenshot without writing browser code A parameter on the Microlink request. On Browserbase you connect Playwright or CDP to a session and capture it yourself.	✓	✕
PDF of the page pdf: true on any Microlink request. Fetch cannot produce or convert PDFs; a session can, through your own code.	✓	✕
Response caching ttl from 1 minute to 31 days, served from the edge without booting a browser. No response cache is documented for Browserbase.	✓	✕
Page metadata Title, description, author, date, logo, image and publisher, normalized. Browserbase reaches the same fields through a Fetch Extract schema you define.	✓	Schema
Named antibot blocker Microlink reports which of 30+ providers refused the request, on every plan. Browserbase offers proxies but documents no blocker attribution.	✓	✕
Markdown Microlink renders first, and also converts PDFs and office documents. Browserbase Fetch Extract converts the fetched HTML.	✓	✓
Structured extraction CSS and regex rules against a rendered page on Microlink; a JSON schema against unrendered HTML on Browserbase.	✓	✓
Run your own browser code Browser Functions give Microlink a Puppeteer page plus any npm package. Browserbase gives you the whole session in your own framework.	✓	✓
Proxy for hard targets Residential routing on Microlink Pro, included in the request price. Browserbase bills proxy traffic per GB.	✓	✓
MCP server Microlink tools each return a finished artifact. Browserbase tools drive a session: start, end, navigate, act, observe, extract.	20 tools	6 tools
Search results Google results as JSON on Microlink paid plans. Browserbase does not disclose its index and caps Search at 120 requests per minute.	✓	✓
Free tier Microlink renews 25 rendered requests every day with no card. Browserbase gives 1 browser hour, 3 concurrent browsers and 15-minute sessions, plus 1,000 Fetch and 1,000 Search calls.	25/day	1 hour
Long-lived, stateful sessions Interactive logins, live view and human takeover need a session that outlives one call. Microlink runs one ephemeral browser per request.	✕	✓
Agent framework primitives Stagehand ships act, extract and observe over the browser, alongside a sandboxed Runtime, Identity and a Model Gateway.	✕	✓
File downloads from a page Browserbase syncs files a session downloads into cloud storage, retrievable through their API.	✕	✓
SOC 2 and HIPAA Browserbase documents SOC 2 Type II, a HIPAA BAA on request, third-party penetration testing and four data-residency regions.	✕	✓

Last verified: August 2026. Check each product’s docs for the latest.

When Browserbase is the better pick.

Microlink returns results, not a browser you hold open and script step by step. Several jobs really are about the browser — and a few are about the paperwork around it.

You drive the browser yourself
When the work is Playwright, Puppeteer, Selenium, or Stagehand code against a live page — arbitrary clicks, multi-step flows, assertions you own — a managed session is the right shape, and Browserbase documents all four frameworks.
Long-lived, stateful sessions
Interactive logins, human-in-the-loop takeover, and watching a running browser live all need a session that outlives a single call. Microlink runs one ephemeral browser per request and returns.
Cheap bulk HTML of static pages
Fetch starts at $0.50 per 1,000 calls on the Startup plan for pages that need no JavaScript. If your targets are server-rendered and you only want the source, that is hard to beat on price alone.
A whole agent platform behind one key
Stagehand, a sandboxed Runtime, Identity, a Model Gateway, and session observability ship together. Microlink is one API that returns web artifacts, not an agent runtime.
Files a page hands you
A Browserbase session syncs files downloaded during automation into cloud storage, retrievable through their API. Microlink returns the artifact it rendered, not whatever a click made the page download.
Compliance and data residency
Browserbase documents SOC 2 Type II, HIPAA with a BAA on request, third-party penetration testing, and regions in US West, US East, EU and Asia. If procurement asks for that list, ask them for it.

browserless

The headless Chrome/Chromium driver on top of Puppeteer. Take screenshots, generate PDFs, extract text and HTML with a production-ready API.

JavaScript

1.8k

mcp

The web browser your AI agent never had

JavaScript

function

Write JavaScript functions and run them remotely with Microlink — Puppeteer access, npm packages, and zero infrastructure.

JavaScript

Built on open source,
trusted by developers

Microlink runs on open source. The rendering engine, the MCP server, and the function runtime are public — read the code, contribute, or self-host instead of renting a browser.

Explore on GitHub

Product Information

How Microlink compares to Browserbase, and when each one fits.

Does Microlink replace Browserbase, or sit next to it?

Not exactly. Browserbase gives you a cloud browser you drive with Playwright, Puppeteer, Selenium, or Stagehand. Microlink is an API that returns finished output — a screenshot, PDF, Markdown, HTML, or structured JSON — from a single call.

If you reach for a browser only to produce one of those results, Microlink replaces the whole session. If you need to script the browser yourself, keep Browserbase.

Browserbase already has a Fetch API that returns Markdown. Why use Microlink?

Because Fetch does not execute JavaScript. Browserbase documents that limit directly, along with a 5 MB content cap, a 60 second timeout, and no PDF conversion.

On a server-rendered page Fetch is an excellent, cheap tool. On a client-rendered app it returns the shell, and the fix is to open a browser session and pay by the browser-hour. Microlink renders every request in a real browser, so the same call works for both and the price does not change.

Can I still run custom browser code on Microlink?

Yes. Browser Functions execute your JavaScript against a live Puppeteer page, and the runtime installs any npm package you require() automatically, caching it for later runs.

You get page-level control without opening and managing a session — but not a persistent, interactive browser you drive end to end.

What replaces browser-hours and concurrency tiers?

Browserbase meters browser-hours, the concurrency tier you sit on, proxy GB, Fetch calls, Search calls, and agent runs — six units to forecast. Microlink charges one request per API call regardless of what comes back, which works out under €1 per 1,000 requests on the entry Pro plan.

Set a ttl and a repeat request is served from the edge without booting a browser.

Both ship an MCP server. What is the difference?

The Browserbase MCP server exposes six tools that operate a session — start, end, navigate, act, observe, and extract — so the agent is still driving a browser, one step at a time.

Microlink MCP exposes 20 tools that each return a finished artifact: screenshot, PDF, Markdown, metadata, media, Lighthouse insights, and Google search. It works without an API key on the free tier, except Search, which needs a paid plan and a key.

What happens on pages behind Cloudflare, DataDome, or Akamai?

Antibot detection runs on every plan and tells you which of 30+ providers refused the request, and the EPROXYNEEDED signal says when a target needs a residential exit rather than failing silently.

Routing through the managed residential pool with proxy: true is a Pro capability. Browserbase also offers proxies, enabled per request and billed per GB.

No. Each Microlink request runs in its own ephemeral browser that is destroyed when the response is sent, so nothing carries over between calls.

You can send cookies or authorization headers on an individual request, but an interactive login you keep alive and reuse is exactly the job Browserbase sessions and contexts exist for.

Which one is safer to point at untrusted URLs?

They solve different halves of it. Browserbase documents a dedicated VM per session, destroyed afterwards, plus SOC 2 Type II and HIPAA with a BAA on request.

Microlink runs one ephemeral browser per call on every plan and refuses private, loopback, and link-local addresses before navigation — the SSRF case you hit when the URL comes from a user. If you need the audited compliance paperwork, Browserbase publishes it and Microlink does not.

The Browserbase alternative that renders in one call

CLI Microlink API example

cURL Microlink API example

JavaScript Microlink API example

Python Microlink API example

Ruby Microlink API example

PHP Microlink API example

Golang Microlink API example

One call. Rendered, not fetched.

JavaScript always runs

Pick the output, not the pipeline

Run code when you need to

Blocked targets are named

Made for AI agents

Isolated and cacheable

What it takes to get the result.

Send the URL Get the rendered result back

Start free, scale when ready

Free

Pro

Enterprise

Start now

Capability by capability, side by side.

When Browserbase is the better pick.

You drive the browser yourself

Long-lived, stateful sessions

Cheap bulk HTML of static pages

A whole agent platform behind one key

Files a page hands you

Compliance and data residency

browserless

mcp

function

Built on open source,trusted by developers

Microlink runs on open source. The rendering engine, the MCP server, and the function runtime are public — read the code, contribute, or self-host instead of renting a browser.

Product Information

How Microlink compares to Browserbase, and when each one fits.

Built on open source,
trusted by developers