Page preparation

Microlink does not just save raw HTML as a PDF. It renders the page in a browser first, which means CSS media rules, dynamic content, banners, and timing all affect the final document.

Choose print or screen CSS

PDF generation uses mediaType: 'print' by default, which usually produces a cleaner document-oriented layout.

If a page looks better in its normal on-screen layout, switch to screen:

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://blog.alexmaccaw.com/advice-to-my-younger-self' URL with 'pdf', 'mediaType' & 'meta' API parameters:

CLI Microlink API example

microlink https://blog.alexmaccaw.com/advice-to-my-younger-self&pdf&mediaType=screen

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://blog.alexmaccaw.com/advice-to-my-younger-self" \
  -d "pdf=true" \
  -d "mediaType=screen" \
  -d "meta=false"

JavaScript Microlink API example

import mql from '@microlink/mql'

const { data } = await mql('https://blog.alexmaccaw.com/advice-to-my-younger-self', {
  pdf: true,
  mediaType: "screen",
  meta: false
})

Python Microlink API example

import requests

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

querystring = {
    "url": "https://blog.alexmaccaw.com/advice-to-my-younger-self",
    "pdf": "true",
    "mediaType": "screen",
    "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://blog.alexmaccaw.com/advice-to-my-younger-self",
  pdf: "true",
  mediaType: "screen",
  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://blog.alexmaccaw.com/advice-to-my-younger-self",
    "pdf" => "true",
    "mediaType" => "screen",
    "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://blog.alexmaccaw.com/advice-to-my-younger-self")
    q.Set("pdf", "true")
    q.Set("mediaType", "screen")
    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))
}

import mql from '@microlink/mql'

const { data } = await mql('https://blog.alexmaccaw.com/advice-to-my-younger-self', {
  pdf: true,
  mediaType: "screen",
  meta: false
})

Use screen when the site’s print stylesheet removes too much or changes the design in ways you do not want.

Value	Best for
`'print'`	Printable, document-first layouts
`'screen'`	Preserving the normal web design

Wait for the right content

Dynamic pages often need a little preparation before the PDF is printed.

Use a lifecycle event

The waitUntil parameter controls what the browser considers “ready”:

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

CLI Microlink API example

microlink https://dev.to&pdf&waitUntil=domcontentloaded

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://dev.to" \
  -d "pdf=true" \
  -d "meta=false" \
  -d "waitUntil=domcontentloaded"

JavaScript Microlink API example

import mql from '@microlink/mql'

const { data } = await mql('https://dev.to', {
  pdf: true,
  meta: false,
  waitUntil: "domcontentloaded"
})

Python Microlink API example

import requests

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

querystring = {
    "url": "https://dev.to",
    "pdf": "true",
    "meta": "false",
    "waitUntil": "domcontentloaded"
}

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://dev.to",
  pdf: "true",
  meta: "false",
  waitUntil: "domcontentloaded"
}

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://dev.to",
    "pdf" => "true",
    "meta" => "false",
    "waitUntil" => "domcontentloaded"
];

$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://dev.to")
    q.Set("pdf", "true")
    q.Set("meta", "false")
    q.Set("waitUntil", "domcontentloaded")
    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 mql from '@microlink/mql'

const { data } = await mql('https://dev.to', {
  pdf: true,
  meta: false,
  waitUntil: "domcontentloaded"
})

For dynamic sites, a faster lifecycle event often works best when paired with a selector wait.

Wait for a specific element

A reliable pattern is to navigate quickly, then wait for the exact content you need:

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

CLI Microlink API example

microlink https://dev.to&pdf&waitUntil=domcontentloaded&waitForSelector=article

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://dev.to" \
  -d "pdf=true" \
  -d "meta=false" \
  -d "waitUntil=domcontentloaded" \
  -d "waitForSelector=article"

JavaScript Microlink API example

import mql from '@microlink/mql'

const { data } = await mql('https://dev.to', {
  pdf: true,
  meta: false,
  waitUntil: "domcontentloaded",
  waitForSelector: "article"
})

Python Microlink API example

import requests

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

querystring = {
    "url": "https://dev.to",
    "pdf": "true",
    "meta": "false",
    "waitUntil": "domcontentloaded",
    "waitForSelector": "article"
}

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://dev.to",
  pdf: "true",
  meta: "false",
  waitUntil: "domcontentloaded",
  waitForSelector: "article"
}

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://dev.to",
    "pdf" => "true",
    "meta" => "false",
    "waitUntil" => "domcontentloaded",
    "waitForSelector" => "article"
];

$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://dev.to")
    q.Set("pdf", "true")
    q.Set("meta", "false")
    q.Set("waitUntil", "domcontentloaded")
    q.Set("waitForSelector", "article")
    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 mql from '@microlink/mql'

const { data } = await mql('https://dev.to', {
  pdf: true,
  meta: false,
  waitUntil: "domcontentloaded",
  waitForSelector: "article"
})

Use waitForSelector when the content you care about appears later than the initial page shell.

Use a fixed delay as a last resort

When there is no stable selector to wait for, use waitForTimeout:

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

CLI Microlink API example

microlink https://dev.to&pdf&waitForTimeout=3s

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://dev.to" \
  -d "pdf=true" \
  -d "meta=false" \
  -d "waitForTimeout=3s"

JavaScript Microlink API example

import mql from '@microlink/mql'

const { data } = await mql('https://dev.to', {
  pdf: true,
  meta: false,
  waitForTimeout: "3s"
})

Python Microlink API example

import requests

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

querystring = {
    "url": "https://dev.to",
    "pdf": "true",
    "meta": "false",
    "waitForTimeout": "3s"
}

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://dev.to",
  pdf: "true",
  meta: "false",
  waitForTimeout: "3s"
}

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://dev.to",
    "pdf" => "true",
    "meta" => "false",
    "waitForTimeout" => "3s"
];

$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://dev.to")
    q.Set("pdf", "true")
    q.Set("meta", "false")
    q.Set("waitForTimeout", "3s")
    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 mql from '@microlink/mql'

const { data } = await mql('https://dev.to', {
  pdf: true,
  meta: false,
  waitForTimeout: "3s"
})

Prefer selector-based waits when possible. Fixed delays are slower and less reliable.

Click before printing

If the page needs one interaction before it is ready, use click:

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

CLI Microlink API example

microlink https://microlink.io&pdf&click=#features

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://microlink.io" \
  -d "pdf=true" \
  -d "meta=false" \
  -d "click=#features"

JavaScript Microlink API example

import mql from '@microlink/mql'

const { data } = await mql('https://microlink.io', {
  pdf: true,
  meta: false,
  click: "#features"
})

Python Microlink API example

import requests

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

querystring = {
    "url": "https://microlink.io",
    "pdf": "true",
    "meta": "false",
    "click": "#features"
}

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://microlink.io",
  pdf: "true",
  meta: "false",
  click: "#features"
}

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://microlink.io",
    "pdf" => "true",
    "meta" => "false",
    "click" => "#features"
];

$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://microlink.io")
    q.Set("pdf", "true")
    q.Set("meta", "false")
    q.Set("click", "#features")
    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 mql from '@microlink/mql'

const { data } = await mql('https://microlink.io', {
  pdf: true,
  meta: false,
  click: "#features"
})

Useful for opening tabs, expanding accordions, or dismissing UI before the PDF is printed.

Clean up the layout with CSS

The styles parameter lets you inject CSS before Microlink prints the page:

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

CLI Microlink API example

microlink https://microlink.io&pdf&styles='header, .navbar, .cookie-banner { display: none !important; },main { max-width: 900px !important; margin: 0 auto !important; }'

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://microlink.io" \
  -d "pdf=true" \
  -d "meta=false" \
  -d "styles=header%2C%20.navbar%2C%20.cookie-banner%20%7B%20display%3A%20none%20!important%3B%20%7D%2Cmain%20%7B%20max-width%3A%20900px%20!important%3B%20margin%3A%200%20auto%20!important%3B%20%7D"

JavaScript Microlink API example

import mql from '@microlink/mql'

const { data } = await mql('https://microlink.io', {
  pdf: true,
  meta: false,
  styles: [
    "header, .navbar, .cookie-banner { display: none !important; }",
    "main { max-width: 900px !important; margin: 0 auto !important; }"
  ]
})

Python Microlink API example

import requests

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

querystring = {
    "url": "https://microlink.io",
    "pdf": "true",
    "meta": "false",
    "styles": "header, .navbar, .cookie-banner { display: none !important; },main { max-width: 900px !important; margin: 0 auto !important; }"
}

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://microlink.io",
  pdf: "true",
  meta: "false",
  styles: "header, .navbar, .cookie-banner { display: none !important; },main { max-width: 900px !important; margin: 0 auto !important; }"
}

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://microlink.io",
    "pdf" => "true",
    "meta" => "false",
    "styles" => "header, .navbar, .cookie-banner { display: none !important; },main { max-width: 900px !important; margin: 0 auto !important; }"
];

$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://microlink.io")
    q.Set("pdf", "true")
    q.Set("meta", "false")
    q.Set("styles", "header, .navbar, .cookie-banner { display: none !important; },main { max-width: 900px !important; margin: 0 auto !important; }")
    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 mql from '@microlink/mql'

const { data } = await mql('https://microlink.io', {
  pdf: true,
  meta: false,
  styles: [
    "header, .navbar, .cookie-banner { display: none !important; }",
    "main { max-width: 900px !important; margin: 0 auto !important; }"
  ]
})

CSS injection is the fastest way to remove sticky navigation, banners, or layout elements that make a PDF look like a website instead of a document.

Common uses:

Hide cookie banners or sticky headers
Narrow wide layouts to improve page breaks
Adjust fonts, spacing, or max-width for cleaner print output

Keep the page clean by default

Ad blocking is enabled by default (adblock: true). That helps remove third-party ads, trackers, and many cookie banners before the page is rendered.

If you need to capture the page exactly as a first-time visitor would see it, disable it:

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

CLI Microlink API example

microlink https://www.youtube.com&pdf

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://www.youtube.com" \
  -d "pdf=true" \
  -d "meta=false" \
  -d "adblock=false"

JavaScript Microlink API example

import mql from '@microlink/mql'

const { data } = await mql('https://www.youtube.com', {
  pdf: true,
  meta: false,
  adblock: false
})

Python Microlink API example

import requests

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

querystring = {
    "url": "https://www.youtube.com",
    "pdf": "true",
    "meta": "false",
    "adblock": "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://www.youtube.com",
  pdf: "true",
  meta: "false",
  adblock: "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://www.youtube.com",
    "pdf" => "true",
    "meta" => "false",
    "adblock" => "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://www.youtube.com")
    q.Set("pdf", "true")
    q.Set("meta", "false")
    q.Set("adblock", "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))
}

import mql from '@microlink/mql'

const { data } = await mql('https://www.youtube.com', {
  pdf: true,
  meta: false,
  adblock: false
})

Leave adblock enabled for cleaner PDFs unless you explicitly need the original noisy page state.

Disable JavaScript when you do not need it

JavaScript is enabled by default. Turn it off when the page is already fully useful without client-side execution:

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

CLI Microlink API example

microlink https://news.ycombinator.com&pdf

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://news.ycombinator.com" \
  -d "pdf=true" \
  -d "meta=false" \
  -d "javascript=false"

JavaScript Microlink API example

import mql from '@microlink/mql'

const { data } = await mql('https://news.ycombinator.com', {
  pdf: true,
  meta: false,
  javascript: false
})

Python Microlink API example

import requests

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

querystring = {
    "url": "https://news.ycombinator.com",
    "pdf": "true",
    "meta": "false",
    "javascript": "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://news.ycombinator.com",
  pdf: "true",
  meta: "false",
  javascript: "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://news.ycombinator.com",
    "pdf" => "true",
    "meta" => "false",
    "javascript" => "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://news.ycombinator.com")
    q.Set("pdf", "true")
    q.Set("meta", "false")
    q.Set("javascript", "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))
}

import mql from '@microlink/mql'

const { data } = await mql('https://news.ycombinator.com', {
  pdf: true,
  meta: false,
  javascript: false
})

Disabling JavaScript can simplify the page and reduce rendering work, especially for static or server-rendered content.

Use function as a last resort

For advanced cleanup or automation, the function parameter gives you full Puppeteer access before the PDF is printed:

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

CLI Microlink API example

microlink https://microlink.io&pdf&function='({ page }) => page.evaluate(() => { document.querySelector('"'"'header'"'"')?.remove() })'

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://microlink.io" \
  -d "pdf=true" \
  -d "meta=false" \
  -d "function=(%7B%20page%20%7D)%20%3D%3E%20page.evaluate(()%20%3D%3E%20%7B%20document.querySelector('header')%3F.remove()%20%7D)"

JavaScript Microlink API example

import mql from '@microlink/mql'

const { data } = await mql('https://microlink.io', {
  pdf: true,
  meta: false,
  function: "({ page }) => page.evaluate(() => { document.querySelector('header')?.remove() })"
})

Python Microlink API example

import requests

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

querystring = {
    "url": "https://microlink.io",
    "pdf": "true",
    "meta": "false",
    "function": '''({ page }) => page.evaluate(() => { document.querySelector('header')?.remove() })'''
}

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://microlink.io",
  pdf: "true",
  meta: "false",
  function: "({ page }) => page.evaluate(() => { document.querySelector('header')?.remove() })"
}

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://microlink.io",
    "pdf" => "true",
    "meta" => "false",
    "function" => "({ page }) => page.evaluate(() => { document.querySelector('header')?.remove() })"
];

$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)
    }
    fn := `({ page }) => page.evaluate(() => { document.querySelector('header')?.remove() })`

    q := u.Query()
    q.Set("url", "https://microlink.io")
    q.Set("pdf", "true")
    q.Set("meta", "false")
    q.Set("function", fn)
    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 mql from '@microlink/mql'

const { data } = await mql('https://microlink.io', {
  pdf: true,
  meta: false,
  function: "({ page }) => page.evaluate(() => { document.querySelector('header')?.remove() })"
})

Reach for function only after trying media type, waits, clicks, and CSS injection. It is the most flexible, but also the most complex option.

See the function reference for the available runtime context and advanced options.

Next step

Learn how to deliver generated PDFs as JSON, direct downloads, or embedded previews in delivery and embedding.