## Table of Contents

- [Page preparation](#page-preparation)
- [Choose print or screen CSS](#choose-print-or-screen-css)
  - [CLI Microlink API example](#cli-microlink-api-example)
  - [cURL Microlink API example](#curl-microlink-api-example)
  - [JavaScript Microlink API example](#javascript-microlink-api-example)
  - [Python Microlink API example](#python-microlink-api-example)
  - [Ruby Microlink API example](#ruby-microlink-api-example)
  - [PHP Microlink API example](#php-microlink-api-example)
  - [Golang Microlink API example](#golang-microlink-api-example)
- [Wait for the right content](#wait-for-the-right-content)
  - [Use a lifecycle event](#use-a-lifecycle-event)
  - [CLI Microlink API example](#cli-microlink-api-example-1)
  - [cURL Microlink API example](#curl-microlink-api-example-1)
  - [JavaScript Microlink API example](#javascript-microlink-api-example-1)
  - [Python Microlink API example](#python-microlink-api-example-1)
  - [Ruby Microlink API example](#ruby-microlink-api-example-1)
  - [PHP Microlink API example](#php-microlink-api-example-1)
  - [Golang Microlink API example](#golang-microlink-api-example-1)
  - [Wait for a specific element](#wait-for-a-specific-element)
  - [CLI Microlink API example](#cli-microlink-api-example-2)
  - [cURL Microlink API example](#curl-microlink-api-example-2)
  - [JavaScript Microlink API example](#javascript-microlink-api-example-2)
  - [Python Microlink API example](#python-microlink-api-example-2)
  - [Ruby Microlink API example](#ruby-microlink-api-example-2)
  - [PHP Microlink API example](#php-microlink-api-example-2)
  - [Golang Microlink API example](#golang-microlink-api-example-2)
  - [Use a fixed delay as a last resort](#use-a-fixed-delay-as-a-last-resort)
  - [CLI Microlink API example](#cli-microlink-api-example-3)
  - [cURL Microlink API example](#curl-microlink-api-example-3)
  - [JavaScript Microlink API example](#javascript-microlink-api-example-3)
  - [Python Microlink API example](#python-microlink-api-example-3)
  - [Ruby Microlink API example](#ruby-microlink-api-example-3)
  - [PHP Microlink API example](#php-microlink-api-example-3)
  - [Golang Microlink API example](#golang-microlink-api-example-3)
- [Click before printing](#click-before-printing)
  - [CLI Microlink API example](#cli-microlink-api-example-4)
  - [cURL Microlink API example](#curl-microlink-api-example-4)
  - [JavaScript Microlink API example](#javascript-microlink-api-example-4)
  - [Python Microlink API example](#python-microlink-api-example-4)
  - [Ruby Microlink API example](#ruby-microlink-api-example-4)
  - [PHP Microlink API example](#php-microlink-api-example-4)
  - [Golang Microlink API example](#golang-microlink-api-example-4)
- [Clean up the layout with CSS](#clean-up-the-layout-with-css)
  - [CLI Microlink API example](#cli-microlink-api-example-5)
  - [cURL Microlink API example](#curl-microlink-api-example-5)
  - [JavaScript Microlink API example](#javascript-microlink-api-example-5)
  - [Python Microlink API example](#python-microlink-api-example-5)
  - [Ruby Microlink API example](#ruby-microlink-api-example-5)
  - [PHP Microlink API example](#php-microlink-api-example-5)
  - [Golang Microlink API example](#golang-microlink-api-example-5)
- [Keep the page clean by default](#keep-the-page-clean-by-default)
  - [CLI Microlink API example](#cli-microlink-api-example-6)
  - [cURL Microlink API example](#curl-microlink-api-example-6)
  - [JavaScript Microlink API example](#javascript-microlink-api-example-6)
  - [Python Microlink API example](#python-microlink-api-example-6)
  - [Ruby Microlink API example](#ruby-microlink-api-example-6)
  - [PHP Microlink API example](#php-microlink-api-example-6)
  - [Golang Microlink API example](#golang-microlink-api-example-6)
- [Disable JavaScript when you do not need it](#disable-javascript-when-you-do-not-need-it)
  - [CLI Microlink API example](#cli-microlink-api-example-7)
  - [cURL Microlink API example](#curl-microlink-api-example-7)
  - [JavaScript Microlink API example](#javascript-microlink-api-example-7)
  - [Python Microlink API example](#python-microlink-api-example-7)
  - [Ruby Microlink API example](#ruby-microlink-api-example-7)
  - [PHP Microlink API example](#php-microlink-api-example-7)
  - [Golang Microlink API example](#golang-microlink-api-example-7)
- [Use function as a last resort](#use-function-as-a-last-resort)
  - [CLI Microlink API example](#cli-microlink-api-example-8)
  - [cURL Microlink API example](#curl-microlink-api-example-8)
  - [JavaScript Microlink API example](#javascript-microlink-api-example-8)
  - [Python Microlink API example](#python-microlink-api-example-8)
  - [Ruby Microlink API example](#ruby-microlink-api-example-8)
  - [PHP Microlink API example](#php-microlink-api-example-8)
  - [Golang Microlink API example](#golang-microlink-api-example-8)

---

[](https://microlink.io/docs/api/getting-started/overview)

[API](https://microlink.io/docs/api/getting-started/overview)

[](https://microlink.io/docs/guides)

GUIDES

[](https://microlink.io/docs/mql/getting-started/overview)

MQL

[](https://microlink.io/docs/sdk/getting-started/overview)

SDK

[](https://microlink.io/docs/cards/getting-started/overview)

CARDS

## 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

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

### cURL Microlink API example

``` bash
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

``` javascript
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

``` python
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

``` ruby
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
<?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

``` bash
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))
}
```

``` javascript
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

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

### cURL Microlink API example

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

### JavaScript Microlink API example

``` javascript
import mql from '@microlink/mql'

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

### Python Microlink API example

``` python
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

``` ruby
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
<?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

``` bash
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))
}
```

``` javascript
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

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

### cURL Microlink API example

``` bash
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

``` javascript
import mql from '@microlink/mql'

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

### Python Microlink API example

``` python
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

``` ruby
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
<?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

``` bash
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))
}
```

``` javascript
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

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

### cURL Microlink API example

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

### JavaScript Microlink API example

``` javascript
import mql from '@microlink/mql'

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

### Python Microlink API example

``` python
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

``` ruby
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
<?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

``` bash
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))
}
```

``` javascript
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

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

### cURL Microlink API example

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

### JavaScript Microlink API example

``` javascript
import mql from '@microlink/mql'

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

### Python Microlink API example

``` python
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

``` ruby
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
<?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

``` bash
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))
}
```

``` javascript
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

``` bash
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

``` bash
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

``` javascript
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

``` python
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

``` ruby
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
<?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

``` bash
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))
}
```

``` javascript
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

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

### cURL Microlink API example

``` bash
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

``` javascript
import mql from '@microlink/mql'

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

### Python Microlink API example

``` python
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

``` ruby
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
<?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

``` bash
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))
}
```

``` javascript
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

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

### cURL Microlink API example

``` bash
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

``` javascript
import mql from '@microlink/mql'

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

### Python Microlink API example

``` python
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

``` ruby
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
<?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

``` bash
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))
}
```

``` javascript
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

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

### cURL Microlink API example

``` bash
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

``` javascript
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

``` python
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

``` ruby
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
<?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

``` bash
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))
}
```

``` javascript
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](https://microlink.io/docs/api/parameters/function) for the available runtime context and advanced options.

Learn how to deliver generated PDFs as JSON, direct downloads, or embedded previews in [delivery and embedding](https://microlink.io/docs/guides/pdf/embedding).