Skip to content

Readable text API for developers

Turn any URL into clean, llm-ready plain text. Navigation, ads, cookie banners and boilerplate stripped out — just the words that matter.

Get Started

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

CLI Microlink API example

microlink https://stripe.com/blog/payment-api-design&data.text.attr=text

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://stripe.com/blog/payment-api-design" \
  -d "data.text.attr=text" \
  -d "meta=false"

JavaScript Microlink API example

import mql from '@microlink/mql'

const { data } = await mql('https://stripe.com/blog/payment-api-design', {
  data: {
    text: {
      attr: "text"
    }
  },
  meta: false
})

Python Microlink API example

import requests

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

querystring = {
    "url": "https://stripe.com/blog/payment-api-design",
    "data.text.attr": "text",
    "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://stripe.com/blog/payment-api-design",
  data.text.attr: "text",
  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://stripe.com/blog/payment-api-design",
    "data.text.attr" => "text",
    "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://stripe.com/blog/payment-api-design")
    q.Set("data.text.attr", "text")
    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 readable text back

2.0
secs
P95 cold response
99.9
%
SLA Guaranteed

Content, not chrome.

Feeding raw HTML to a model burns tokens on navigation, scripts and footers. Microlink renders the page, isolates the main content, and returns text you can embed or prompt with directly.

Boilerplate removed
Headers, sidebars, cookie notices, share widgets and footers are dropped. What is left is the article, the docs page, or the product copy.
Rendered before extraction
Content injected by JavaScript is captured too, so client-rendered blogs and docs sites return their real text rather than an empty shell.
Fewer tokens per page
Plain text is a fraction of the size of the source HTML, which cuts both the cost and the latency of every downstream model call.
Works on documents too
PDFs, Word files and slide decks resolve to text through the same endpoint — see file conversion.
Structure when you want it
Need headings and links preserved? Ask for markdown instead, or request both in the same call.

Start free, scale when ready

No signup, no API key, no credit card. The readable text 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

html-get

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

JavaScript
103

metascraper

Scrape metadata from any URL using Open Graph, JSON-LD, HTML meta tags, and smart fallbacks.

HTML
2.7k

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

Built on open source,
trusted by developers

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

Explore on GitHub

Every page, reduced to the words that matter.

Stop paying model tokens to read navigation bars. Send a URL and get back clean prose, ready to embed or prompt with, via the data API.

  • Boilerplate Stripped

    Navigation, sidebars, consent banners, ads and footers are removed so the response carries only the content of the page.

  • JavaScript Rendered First

    Text is extracted after the page hydrates, so client-rendered blogs, docs and single-page apps return their real content.

  • Built For LLM Pipelines

    Plain text is a fraction of the size of source HTML, cutting the cost and latency of every embedding, classification and summarisation call.

  • Documents Supported

    PDFs, Word files, spreadsheets and slide decks resolve to text through the same endpoint, so one integration covers pages and documents.

  • Structure On Demand

    Request markdown alongside text when headings, lists and links matter, and pay for a single render instead of two.

  • Residential Proxy Resolution

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

  • Edge Cached Responses

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

  • Enterprise-Grade Reliability

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

  • 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.

  • Boilerplate Stripped

    Navigation, sidebars, consent banners, ads and footers are removed so the response carries only the content of the page.

  • JavaScript Rendered First

    Text is extracted after the page hydrates, so client-rendered blogs, docs and single-page apps return their real content.

  • Built For LLM Pipelines

    Plain text is a fraction of the size of source HTML, cutting the cost and latency of every embedding, classification and summarisation call.

  • Documents Supported

    PDFs, Word files, spreadsheets and slide decks resolve to text through the same endpoint, so one integration covers pages and documents.

  • Structure On Demand

    Request markdown alongside text when headings, lists and links matter, and pay for a single render instead of two.

  • Residential Proxy Resolution

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

  • Edge Cached Responses

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

  • Enterprise-Grade Reliability

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

  • 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 readable text API is free to use, with no account and no credit card. Point it at a URL and start feeding clean content to your models.
Get started free
No login needed
25 reqs/day free
No credit card

Product Information

Everything you need to know about the Microlink readable text API.

What exactly gets removed from the page?

Navigation bars, sidebars, cookie and consent banners, advertising slots, share widgets, related-content modules and footers. What remains is the main content of the page — the article body, documentation section or product description.

Should I use text or markdown?

Use text when you want the smallest possible payload for embeddings, classification or summarisation.
Use markdown when structure matters — headings, lists, links and code blocks are preserved so a model can follow the document hierarchy. You can request both in one call.

Does it work on JavaScript-rendered sites?

Yes. Every request runs in a real browser, so content injected after load is present before the text is extracted. Client-rendered blogs, docs sites and single-page apps all return their actual content.

Can I extract text from a PDF or a Word document?

Yes. Point the API at a document URL and it is converted before extraction, so PDFs, Word files, spreadsheets and slide decks all resolve to plain text through the same endpoint.

How much does this reduce token usage?

It depends on the page, but plain text is typically a small fraction of the source HTML, since markup, scripts, styles and navigation are all discarded. That reduction applies to every model call you make with the content.

What happens when a site blocks the request?

Enable proxy resolution to route through residential IPs, and antibot detection will tell you which provider blocked a request if one still does. Both work on the same call that returns the text.