Skip to content

Rendered HTML API for developers

Get the HTML a real browser sees, after JavaScript has run. One REST call returns the fully hydrated DOM of any URL, no headless chrome to operate.

Get Started

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

CLI Microlink API example

microlink https://vercel.com&data.html.attr=html

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://vercel.com" \
  -d "data.html.attr=html" \
  -d "meta=false"

JavaScript Microlink API example

import mql from '@microlink/mql'

const { data } = await mql('https://vercel.com', {
  data: {
    html: {
      attr: "html"
    }
  },
  meta: false
})

Python Microlink API example

import requests

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

querystring = {
    "url": "https://vercel.com",
    "data.html.attr": "html",
    "meta": "false"
}

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",
  data.html.attr: "html",
  meta: "false"
}

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",
    "data.html.attr" => "html",
    "meta" => "false"
];

$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("data.html.attr", "html")
    q.Set("meta", "false")
    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))
}

Send the URL Get the rendered HTML back

2.0
secs
P95 cold response
99.9
%
SLA Guaranteed

The DOM after JavaScript,
not before.

A plain HTTP fetch gives you an empty shell on any modern site. Microlink boots a real browser, waits for the app to hydrate, and hands back the markup that actually rendered.

JavaScript fully executed
React, Vue, Svelte and Angular apps are rendered before capture. Client-side routes, hydrated content and lazy sections are all in the response.
Wait for what matters
Control readiness with waitUntil and waitFor. Block until the network settles, or until a specific selector exists on the page.
Scope to a selector
Return the whole document or just the subtree you care about. Smaller payloads, less parsing, lower token cost downstream.
Gets past the hard pages
Residential proxy resolution and antibot detection handle the sites that block plain fetches.
Pairs with every other output
Ask for HTML alongside markdown, text, metadata or a screenshot in the same request.

Start free, scale when ready

No signup, no API key, no credit card. The rendered HTML API is free to start — just call the endpoint.

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

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

html-get

Get the HTML from any website, fine-tuned for correction & speed

JavaScript
103

html

Get HTML from any URL.

JavaScript
5

Built on open source,
trusted by developers

The Microlink rendering engine is powered by battle-tested open source libraries used by thousands of developers worldwide. Our rendered HTML API is built on an open source foundation: explore the code, contribute, or run it yourself.

Explore on GitHub

The markup a browser sees, without running one.

No Chromium fleet to patch, no proxy pool to rotate, no queue to babysit. Send a URL and get back the hydrated DOM, ready to parse via the data API.

  • Real Browser Rendering

    Every request runs in a real Chromium instance, so client-rendered apps return complete markup instead of an empty shell.

  • Selector Scoping

    Return the whole document or a single subtree. Smaller responses mean less parsing and lower token cost in whatever consumes them.

  • Readiness You Control

    waitUntil and waitFor let you block on network idle, a fixed delay, or the appearance of a specific element before the HTML is captured.

  • Residential Proxy Resolution

    Route hard targets through residential IPs to get past Cloudflare, DataDome and Akamai without maintaining a proxy pool yourself.

  • Antibot Transparency

    When a request is blocked you get told which of 30+ antibot and CAPTCHA providers blocked it, instead of a silent failure.

  • Edge Cached Responses

    Configurable TTL from 1 minute to 31 days. Cache hits are free, return instantly, and never boot a browser.

  • One Call, Many Formats

    Request HTML together with markdown, text, metadata, screenshots or PDFs and pay for a single render instead of several.

  • Enterprise-Grade Reliability

    Production-ready infrastructure with a 99.9% uptime SLA and guaranteed performance for business-critical extraction workflows.

  • Generous Free Tier

    Start immediately with 25 requests/day. No setup fees, no credit card, and pay-as-you-grow pricing that scales with your usage.

  • Real Browser Rendering

    Every request runs in a real Chromium instance, so client-rendered apps return complete markup instead of an empty shell.

  • Selector Scoping

    Return the whole document or a single subtree. Smaller responses mean less parsing and lower token cost in whatever consumes them.

  • Readiness You Control

    waitUntil and waitFor let you block on network idle, a fixed delay, or the appearance of a specific element before the HTML is captured.

  • Residential Proxy Resolution

    Route hard targets through residential IPs to get past Cloudflare, DataDome and Akamai without maintaining a proxy pool yourself.

  • Antibot Transparency

    When a request is blocked you get told which of 30+ antibot and CAPTCHA providers blocked it, instead of a silent failure.

  • Edge Cached Responses

    Configurable TTL from 1 minute to 31 days. Cache hits are free, return instantly, and never boot a browser.

  • One Call, Many Formats

    Request HTML together with markdown, text, metadata, screenshots or PDFs and pay for a single render instead of several.

  • Enterprise-Grade Reliability

    Production-ready infrastructure with a 99.9% uptime SLA and guaranteed performance for business-critical extraction workflows.

  • Generous Free Tier

    Start immediately with 25 requests/day. No setup fees, no credit card, and pay-as-you-grow pricing that scales with your usage.

Start now

Get 25 requests/day with zero commitment. The rendered HTML API is free to use, with no account and no credit card. Call it and start parsing real markup in seconds.
Get started free
No login needed
25 reqs/day free
No credit card

Product Information

Everything you need to know about the Microlink rendered HTML API.

How is this different from fetching the URL myself?

A plain HTTP fetch returns whatever the server sent — on a single-page app that is usually an empty div. Microlink loads the URL in a real browser, runs the JavaScript, waits for the page to settle, and returns the resulting DOM.
You get the markup a user would actually see, without operating Chromium yourself.

Can I get only part of the page instead of the whole document?

Yes. Scope the response to a CSS selector so you receive just that subtree rather than the entire document. This keeps payloads small and cuts the parsing and token cost of anything you do downstream.

How do I make sure the page is fully loaded before capture?

Use waitUntil to choose the network condition to block on, and waitFor to block until a specific selector appears or for a fixed duration. Together they cover slow hydration, lazy-loaded sections and client-side routing.

What happens on sites that block automated requests?

Microlink runs every request in an isolated browser with a real fingerprint. For hard targets you can enable proxy resolution to route through residential IPs, and antibot detection tells you exactly which provider blocked a request and why.

Does every call boot a browser?

Only on a cache miss. Set a ttl and any repeat request for the same URL inside that window is served from the edge cache instantly, at no cost and without booting a browser.

Can I get HTML and other formats in one request?

Yes. HTML, markdown, text, metadata, screenshots and PDFs all come from the same endpoint, so a single call can return several representations of the same page without paying for repeated renders.