## Table of Contents

- [Browser settings](#browser-settings)
- [Device emulation](#device-emulation)
  - [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)
  - [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)
- [Custom viewport](#custom-viewport)
  - [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)
  - [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)
- [Color scheme (dark mode)](#color-scheme-dark-mode)
  - [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)
- [CSS media type](#css-media-type)
  - [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)
- [Animations](#animations)
  - [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)
- [JavaScript execution](#javascript-execution)
  - [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)

---

[](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

## Browser settings

The browser that renders your screenshot can be configured to emulate different devices, screen sizes, and rendering preferences. These settings affect the entire page rendering process, not just the final image output.

## Device emulation

The fastest way to simulate a specific device is the `device` parameter. It sets the viewport, user agent, and screen resolution in one go:

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

### CLI Microlink API example

``` bash
microlink https://microlink.io&screenshot&device='iPhone 15 Pro'
```

### cURL Microlink API example

``` bash
curl -G "https://api.microlink.io" \
  -d "url=https://microlink.io" \
  -d "screenshot=true" \
  -d "device=iPhone%2015%20Pro" \
  -d "meta=false"
```

### JavaScript Microlink API example

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

const { data } = await mql('https://microlink.io', {
  screenshot: true,
  device: "iPhone 15 Pro",
  meta: false
})
```

### Python Microlink API example

``` python
import requests

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

querystring = {
    "url": "https://microlink.io",
    "screenshot": "true",
    "device": "iPhone 15 Pro",
    "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://microlink.io",
  screenshot: "true",
  device: "iPhone 15 Pro",
  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://microlink.io",
    "screenshot" => "true",
    "device" => "iPhone 15 Pro",
    "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://microlink.io")
    q.Set("screenshot", "true")
    q.Set("device", "iPhone 15 Pro")
    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://microlink.io', {

  screenshot: true,

  device: "iPhone 15 Pro",

  meta: false

})
```

Device names are case-insensitive. The default is `'macbook pro 13'`.

Supported devices include:

| Category | Examples                                          |
| -------- | ------------------------------------------------- |
| Mobile   | iPhone 15 Pro Max, iPhone 14, Pixel 5, Galaxy S9+ |
| Tablet   | iPad, iPad Pro, iPad Mini, Galaxy Tab S4          |
| Desktop  | Macbook Pro 13, Macbook Pro 16, iMac 27 5K        |

See the [device reference](https://microlink.io/docs/api/parameters/device) for the full list of supported devices.

Capturing the same page across devices is as simple as changing the `device` value:

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

### CLI Microlink API example

``` bash
microlink https://microlink.io&screenshot&device=iPad
```

### cURL Microlink API example

``` bash
curl -G "https://api.microlink.io" \
  -d "url=https://microlink.io" \
  -d "screenshot=true" \
  -d "device=iPad" \
  -d "meta=false"
```

### JavaScript Microlink API example

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

const { data } = await mql('https://microlink.io', {
  screenshot: true,
  device: "iPad",
  meta: false
})
```

### Python Microlink API example

``` python
import requests

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

querystring = {
    "url": "https://microlink.io",
    "screenshot": "true",
    "device": "iPad",
    "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://microlink.io",
  screenshot: "true",
  device: "iPad",
  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://microlink.io",
    "screenshot" => "true",
    "device" => "iPad",
    "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://microlink.io")
    q.Set("screenshot", "true")
    q.Set("device", "iPad")
    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://microlink.io', {

  screenshot: true,

  device: "iPad",

  meta: false

})
```

Tablet viewport with the iPad preset.

## Custom viewport

For fine-grained control, use `viewport` to set individual properties. Any values you provide are merged with the default device settings:

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://en.wikipedia.org/wiki/Bob_Dylan' URL with 'screenshot', 'viewport' & 'meta' API parameters:

### CLI Microlink API example

``` bash
microlink https://en.wikipedia.org/wiki/Bob_Dylan&screenshot&viewport.width=640&viewport.height=400&viewport.deviceScaleFactor=2&viewport.isMobile
```

### cURL Microlink API example

``` bash
curl -G "https://api.microlink.io" \
  -d "url=https://en.wikipedia.org/wiki/Bob_Dylan" \
  -d "screenshot=true" \
  -d "viewport.width=640" \
  -d "viewport.height=400" \
  -d "viewport.deviceScaleFactor=2" \
  -d "viewport.isMobile=true" \
  -d "meta=false"
```

### JavaScript Microlink API example

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

const { data } = await mql('https://en.wikipedia.org/wiki/Bob_Dylan', {
  screenshot: true,
  viewport: {
    width: 640,
    height: 400,
    deviceScaleFactor: 2,
    isMobile: true
  },
  meta: false
})
```

### Python Microlink API example

``` python
import requests

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

querystring = {
    "url": "https://en.wikipedia.org/wiki/Bob_Dylan",
    "screenshot": "true",
    "viewport.width": "640",
    "viewport.height": "400",
    "viewport.deviceScaleFactor": "2",
    "viewport.isMobile": "true",
    "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://en.wikipedia.org/wiki/Bob_Dylan",
  screenshot: "true",
  viewport.width: "640",
  viewport.height: "400",
  viewport.deviceScaleFactor: "2",
  viewport.isMobile: "true",
  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://en.wikipedia.org/wiki/Bob_Dylan",
    "screenshot" => "true",
    "viewport.width" => "640",
    "viewport.height" => "400",
    "viewport.deviceScaleFactor" => "2",
    "viewport.isMobile" => "true",
    "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://en.wikipedia.org/wiki/Bob_Dylan")
    q.Set("screenshot", "true")
    q.Set("viewport.width", "640")
    q.Set("viewport.height", "400")
    q.Set("viewport.deviceScaleFactor", "2")
    q.Set("viewport.isMobile", "true")
    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://en.wikipedia.org/wiki/Bob_Dylan', {

  screenshot: true,

  viewport: {

    width: 640,

    height: 400,

    deviceScaleFactor: 2,

    isMobile: true

  },

  meta: false

})
```

A custom 640×400 viewport at 2× pixel density with mobile meta viewport enabled.

Available viewport properties:

| Property            | Type        | Description                              |
| ------------------- | ----------- | ---------------------------------------- |
| `width`             | `<number>`  | Page width in pixels                     |
| `height`            | `<number>`  | Page height in pixels                    |
| `deviceScaleFactor` | `<number>`  | Pixel density (1 = standard, 2 = retina) |
| `isMobile`          | `<boolean>` | Respect the `<meta viewport>` tag        |
| `hasTouch`          | `<boolean>` | Enable touch event support               |
| `isLandscape`       | `<boolean>` | Landscape orientation                    |

A good pattern is to start with a `device` preset, then override only the viewport property you need:

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://en.wikipedia.org/wiki/Bob_Dylan' URL with 'screenshot', 'viewport' & 'meta' API parameters:

### CLI Microlink API example

``` bash
microlink https://en.wikipedia.org/wiki/Bob_Dylan&screenshot&viewport.deviceScaleFactor=0.5
```

### cURL Microlink API example

``` bash
curl -G "https://api.microlink.io" \
  -d "url=https://en.wikipedia.org/wiki/Bob_Dylan" \
  -d "screenshot=true" \
  -d "viewport.deviceScaleFactor=0.5" \
  -d "meta=false"
```

### JavaScript Microlink API example

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

const { data } = await mql('https://en.wikipedia.org/wiki/Bob_Dylan', {
  screenshot: true,
  viewport: {
    deviceScaleFactor: 0.5
  },
  meta: false
})
```

### Python Microlink API example

``` python
import requests

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

querystring = {
    "url": "https://en.wikipedia.org/wiki/Bob_Dylan",
    "screenshot": "true",
    "viewport.deviceScaleFactor": "0.5",
    "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://en.wikipedia.org/wiki/Bob_Dylan",
  screenshot: "true",
  viewport.deviceScaleFactor: "0.5",
  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://en.wikipedia.org/wiki/Bob_Dylan",
    "screenshot" => "true",
    "viewport.deviceScaleFactor" => "0.5",
    "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://en.wikipedia.org/wiki/Bob_Dylan")
    q.Set("screenshot", "true")
    q.Set("viewport.deviceScaleFactor", "0.5")
    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://en.wikipedia.org/wiki/Bob_Dylan', {

  screenshot: true,

  viewport: {

    deviceScaleFactor: 0.5

  },

  meta: false

})
```

Same default viewport but at half the pixel density — useful for faster, lighter screenshots.

## Color scheme (dark mode)

Force a page to render in light or dark mode using `colorScheme`:

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://googlechromelabs.github.io/dark-mode-toggle/demo' URL with 'screenshot', 'colorScheme' & 'meta' API parameters:

### CLI Microlink API example

``` bash
microlink https://googlechromelabs.github.io/dark-mode-toggle/demo&screenshot&colorScheme=dark
```

### cURL Microlink API example

``` bash
curl -G "https://api.microlink.io" \
  -d "url=https://googlechromelabs.github.io/dark-mode-toggle/demo" \
  -d "screenshot=true" \
  -d "colorScheme=dark" \
  -d "meta=false"
```

### JavaScript Microlink API example

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

const { data } = await mql('https://googlechromelabs.github.io/dark-mode-toggle/demo', {
  screenshot: true,
  colorScheme: "dark",
  meta: false
})
```

### Python Microlink API example

``` python
import requests

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

querystring = {
    "url": "https://googlechromelabs.github.io/dark-mode-toggle/demo",
    "screenshot": "true",
    "colorScheme": "dark",
    "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://googlechromelabs.github.io/dark-mode-toggle/demo",
  screenshot: "true",
  colorScheme: "dark",
  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://googlechromelabs.github.io/dark-mode-toggle/demo",
    "screenshot" => "true",
    "colorScheme" => "dark",
    "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://googlechromelabs.github.io/dark-mode-toggle/demo")
    q.Set("screenshot", "true")
    q.Set("colorScheme", "dark")
    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://googlechromelabs.github.io/dark-mode-toggle/demo', {

  screenshot: true,

  colorScheme: "dark",

  meta: false

})
```

This sets the `prefers-color-scheme` CSS media feature in the browser.

Supported values:

| Value             | Effect                                   |
| ----------------- | ---------------------------------------- |
| `'no-preference'` | Default — uses the site's default scheme |
| `'light'`         | Forces light mode                        |
| `'dark'`          | Forces dark mode                         |

This only works on sites that implement `prefers-color-scheme` media queries. If the site doesn't support it, the parameter has no effect.

## CSS media type

The `mediaType` parameter controls which CSS media rules are applied:

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://en.wikipedia.org/wiki/Bob_Dylan' URL with 'screenshot', 'mediaType' & 'meta' API parameters:

### CLI Microlink API example

``` bash
microlink https://en.wikipedia.org/wiki/Bob_Dylan&screenshot&mediaType=print
```

### cURL Microlink API example

``` bash
curl -G "https://api.microlink.io" \
  -d "url=https://en.wikipedia.org/wiki/Bob_Dylan" \
  -d "screenshot=true" \
  -d "mediaType=print" \
  -d "meta=false"
```

### JavaScript Microlink API example

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

const { data } = await mql('https://en.wikipedia.org/wiki/Bob_Dylan', {
  screenshot: true,
  mediaType: "print",
  meta: false
})
```

### Python Microlink API example

``` python
import requests

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

querystring = {
    "url": "https://en.wikipedia.org/wiki/Bob_Dylan",
    "screenshot": "true",
    "mediaType": "print",
    "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://en.wikipedia.org/wiki/Bob_Dylan",
  screenshot: "true",
  mediaType: "print",
  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://en.wikipedia.org/wiki/Bob_Dylan",
    "screenshot" => "true",
    "mediaType" => "print",
    "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://en.wikipedia.org/wiki/Bob_Dylan")
    q.Set("screenshot", "true")
    q.Set("mediaType", "print")
    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://en.wikipedia.org/wiki/Bob_Dylan', {

  screenshot: true,

  mediaType: "print",

  meta: false

})
```

The `'print'` media type activates print stylesheets — useful for capturing a cleaner, ad-free layout.

| Value      | Effect                                           |
| ---------- | ------------------------------------------------ |
| `'screen'` | Standard web rendering (default for screenshots) |
| `'print'`  | Print stylesheet rendering                       |

## Animations

CSS animations and transitions are **disabled by default** for screenshots, ensuring you capture a stable, deterministic state:

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', 'animations' & 'meta' API parameters:

### CLI Microlink API example

``` bash
microlink https://vercel.com&screenshot
```

### cURL Microlink API example

``` bash
curl -G "https://api.microlink.io" \
  -d "url=https://vercel.com" \
  -d "screenshot=true" \
  -d "animations=false" \
  -d "meta=false"
```

### JavaScript Microlink API example

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

const { data } = await mql('https://vercel.com', {
  screenshot: true,
  animations: false,
  meta: false
})
```

### Python Microlink API example

``` python
import requests

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

querystring = {
    "url": "https://vercel.com",
    "screenshot": "true",
    "animations": "false",
    "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://vercel.com",
  screenshot: "true",
  animations: "false",
  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://vercel.com",
    "screenshot" => "true",
    "animations" => "false",
    "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://vercel.com")
    q.Set("screenshot", "true")
    q.Set("animations", "false")
    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://vercel.com', {

  screenshot: true,

  animations: false,

  meta: false

})
```

With `animations: false` (the default), all CSS animations and transitions are frozen. This also sets `prefers-reduced-motion: reduce`.

Set `animations: true` if you want to capture a page mid-animation (for example, a hero section with an entrance effect), but be aware that the result may vary between captures.

## JavaScript execution

JavaScript is enabled by default. Disable it to capture a page as-if the browser had JS turned off:

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

### CLI Microlink API example

``` bash
microlink https://microlink.io&screenshot
```

### cURL Microlink API example

``` bash
curl -G "https://api.microlink.io" \
  -d "url=https://microlink.io" \
  -d "screenshot=true" \
  -d "javascript=false" \
  -d "meta=false"
```

### JavaScript Microlink API example

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

const { data } = await mql('https://microlink.io', {
  screenshot: true,
  javascript: false,
  meta: false
})
```

### Python Microlink API example

``` python
import requests

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

querystring = {
    "url": "https://microlink.io",
    "screenshot": "true",
    "javascript": "false",
    "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://microlink.io",
  screenshot: "true",
  javascript: "false",
  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://microlink.io",
    "screenshot" => "true",
    "javascript" => "false",
    "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://microlink.io")
    q.Set("screenshot", "true")
    q.Set("javascript", "false")
    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://microlink.io', {

  screenshot: true,

  javascript: false,

  meta: false

})
```

Useful for checking how a page degrades without JavaScript, or for capturing static HTML content faster.

Disabling JavaScript means SPAs (React, Vue, Angular) will often render their initial server-side HTML only. Use this when the target page is already fully useful without client-side execution.

Learn how to interact with the page before capturing — clicking elements, scrolling, waiting, and injecting code — in [page interaction](https://microlink.io/docs/guides/screenshot/page-interaction).