## Table of Contents

- [Page preparation](#page-preparation)
- [Choose fetch mode first](#choose-fetch-mode-first)
  - [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)
- [Render the right page variant](#render-the-right-page-variant)
  - [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 dynamic content](#wait-for-dynamic-content)
  - [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)
- [Change the page state first](#change-the-page-state-first)
  - [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)
- [Use scripts, modules, and function only when needed](#use-scripts-modules-and-function-only-when-needed)
  - [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)

---

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

The quality of your extracted data depends on the DOM Microlink sees. This page covers the rendering and interaction options that change that DOM before your `data` rules run.

## Choose fetch mode first

The biggest rendering decision is `prerender`:

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

### CLI Microlink API example

``` bash
microlink https://example.com&data.title.selector=h1&data.title.attr=text
```

### cURL Microlink API example

``` bash
curl -G "https://api.microlink.io" \
  -d "url=https://example.com" \
  -d "data.title.selector=h1" \
  -d "data.title.attr=text" \
  -d "meta=false" \
  -d "prerender=false"
```

### JavaScript Microlink API example

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

const { data } = await mql('https://example.com', {
  data: {
    title: {
      selector: "h1",
      attr: "text"
    }
  },
  meta: false,
  prerender: false
})
```

### Python Microlink API example

``` python
import requests

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

querystring = {
    "url": "https://example.com",
    "data.title.selector": "h1",
    "data.title.attr": "text",
    "meta": "false",
    "prerender": "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://example.com",
  data.title.selector: "h1",
  data.title.attr: "text",
  meta: "false",
  prerender: "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://example.com",
    "data.title.selector" => "h1",
    "data.title.attr" => "text",
    "meta" => "false",
    "prerender" => "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://example.com")
    q.Set("data.title.selector", "h1")
    q.Set("data.title.attr", "text")
    q.Set("meta", "false")
    q.Set("prerender", "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://example.com', {

  data: {

    title: {

      selector: "h1",

      attr: "text"

    }

  },

  meta: false,

  prerender: false

})
```

Use `prerender: false` when the page already contains the content in its initial HTML and does not need browser execution.

| If the page                                                       | Use                           |
| ----------------------------------------------------------------- | ----------------------------- |
| Is static HTML or a simple server-rendered document               | `prerender: false`            |
| Might need a browser, but you are not sure                        | `prerender: 'auto'` (default) |
| Is client-rendered and comes back empty without browser execution | `prerender: true`             |

If you still need a browser render but the page does not require scripts, `javascript: false` can be another useful speed and reliability lever.

## Render the right page variant

Responsive layouts, print styles, and locale-specific UIs can all change the values you extract.

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

### CLI Microlink API example

``` bash
microlink https://microlink.io&data.title.selector=h1&data.title.attr=text&device='iPhone 15 Pro'
```

### cURL Microlink API example

``` bash
curl -G "https://api.microlink.io" \
  -d "url=https://microlink.io" \
  -d "data.title.selector=h1" \
  -d "data.title.attr=text" \
  -d "meta=false" \
  -d "device=iPhone%2015%20Pro"
```

### JavaScript Microlink API example

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

const { data } = await mql('https://microlink.io', {
  data: {
    title: {
      selector: "h1",
      attr: "text"
    }
  },
  meta: false,
  device: "iPhone 15 Pro"
})
```

### Python Microlink API example

``` python
import requests

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

querystring = {
    "url": "https://microlink.io",
    "data.title.selector": "h1",
    "data.title.attr": "text",
    "meta": "false",
    "device": "iPhone 15 Pro"
}

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",
  data.title.selector: "h1",
  data.title.attr: "text",
  meta: "false",
  device: "iPhone 15 Pro"
}

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",
    "data.title.selector" => "h1",
    "data.title.attr" => "text",
    "meta" => "false",
    "device" => "iPhone 15 Pro"
];

$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("data.title.selector", "h1")
    q.Set("data.title.attr", "text")
    q.Set("meta", "false")
    q.Set("device", "iPhone 15 Pro")
    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', {

  data: {

    title: {

      selector: "h1",

      attr: "text"

    }

  },

  meta: false,

  device: "iPhone 15 Pro"

})
```

Use `device` when the target site renders a different mobile or tablet variant.

The main rendering controls are:

- `device` — loads a known device preset, including viewport and user agent.

- `viewport` — overrides width, height, scale factor, and mobile flags when the preset is not enough.

- `mediaType` — switches between `'screen'` and `'print'`, which matters when the site ships print-specific CSS.

- `headers`

  PRO

  — can shape locale or other request-dependent variants. See [private pages](https://microlink.io/docs/guides/data-extraction/private-pages).

Choose these settings before you tweak selectors. Often the best selector is the same, but the wrong page variant is being rendered.

## Wait for dynamic content

Dynamic pages often need time before the final content exists in the DOM.

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

### CLI Microlink API example

``` bash
microlink https://dev.to&data.title.selector='main h1'&data.title.attr=text&waitUntil=domcontentloaded&waitForSelector='main h1'
```

### cURL Microlink API example

``` bash
curl -G "https://api.microlink.io" \
  -d "url=https://dev.to" \
  -d "data.title.selector=main%20h1" \
  -d "data.title.attr=text" \
  -d "meta=false" \
  -d "waitUntil=domcontentloaded" \
  -d "waitForSelector=main%20h1"
```

### JavaScript Microlink API example

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

const { data } = await mql('https://dev.to', {
  data: {
    title: {
      selector: "main h1",
      attr: "text"
    }
  },
  meta: false,
  waitUntil: "domcontentloaded",
  waitForSelector: "main h1"
})
```

### Python Microlink API example

``` python
import requests

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

querystring = {
    "url": "https://dev.to",
    "data.title.selector": "main h1",
    "data.title.attr": "text",
    "meta": "false",
    "waitUntil": "domcontentloaded",
    "waitForSelector": "main h1"
}

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",
  data.title.selector: "main h1",
  data.title.attr: "text",
  meta: "false",
  waitUntil: "domcontentloaded",
  waitForSelector: "main h1"
}

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",
    "data.title.selector" => "main h1",
    "data.title.attr" => "text",
    "meta" => "false",
    "waitUntil" => "domcontentloaded",
    "waitForSelector" => "main h1"
];

$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("data.title.selector", "main h1")
    q.Set("data.title.attr", "text")
    q.Set("meta", "false")
    q.Set("waitUntil", "domcontentloaded")
    q.Set("waitForSelector", "main h1")
    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', {

  data: {

    title: {

      selector: "main h1",

      attr: "text"

    }

  },

  meta: false,

  waitUntil: "domcontentloaded",

  waitForSelector: "main h1"

})
```

Navigate quickly, then wait for the exact element you plan to extract.

Use the wait controls in this order:

| Need                                                      | Best option                     |
| --------------------------------------------------------- | ------------------------------- |
| A good default navigation signal                          | `waitUntil: 'auto'`             |
| Faster navigation before a selector wait                  | `waitUntil: 'domcontentloaded'` |
| Wait for a specific field or wrapper to appear            | `waitForSelector`               |
| Handle delayed hydration when there is no stable selector | `waitForTimeout`                |

You can also pass an array to `waitUntil` when a page needs more than one lifecycle event.

## Change the page state first

Ad blocking is **enabled by default** (`adblock: true`). That removes many ads, trackers, and consent layers before extraction.

When that is not enough, mutate the page before your rules run:

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

### CLI Microlink API example

``` bash
microlink https://microlink.io&data.pricing.selector=#pricing&data.pricing.attr=text&click=#features&scroll=#pricing&styles='header, footer { display: none !important; }'
```

### cURL Microlink API example

``` bash
curl -G "https://api.microlink.io" \
  -d "url=https://microlink.io" \
  -d "data.pricing.selector=#pricing" \
  -d "data.pricing.attr=text" \
  -d "meta=false" \
  -d "click=#features" \
  -d "scroll=#pricing" \
  -d "styles=header%2C%20footer%20%7B%20display%3A%20none%20!important%3B%20%7D"
```

### JavaScript Microlink API example

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

const { data } = await mql('https://microlink.io', {
  data: {
    pricing: {
      selector: "#pricing",
      attr: "text"
    }
  },
  meta: false,
  click: "#features",
  scroll: "#pricing",
  styles: [
    "header, footer { display: none !important; }"
  ]
})
```

### Python Microlink API example

``` python
import requests

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

querystring = {
    "url": "https://microlink.io",
    "data.pricing.selector": "#pricing",
    "data.pricing.attr": "text",
    "meta": "false",
    "click": "#features",
    "scroll": "#pricing",
    "styles": "header, footer { display: none !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",
  data.pricing.selector: "#pricing",
  data.pricing.attr: "text",
  meta: "false",
  click: "#features",
  scroll: "#pricing",
  styles: "header, footer { display: none !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",
    "data.pricing.selector" => "#pricing",
    "data.pricing.attr" => "text",
    "meta" => "false",
    "click" => "#features",
    "scroll" => "#pricing",
    "styles" => "header, footer { display: none !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("data.pricing.selector", "#pricing")
    q.Set("data.pricing.attr", "text")
    q.Set("meta", "false")
    q.Set("click", "#features")
    q.Set("scroll", "#pricing")
    q.Set("styles", "header, footer { display: none !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', {

  data: {

    pricing: {

      selector: "#pricing",

      attr: "text"

    }

  },

  meta: false,

  click: "#features",

  scroll: "#pricing",

  styles: [

    "header, footer { display: none !important; }"

  ]

})
```

Think in page state: click what needs opening, scroll if lazy content loads on view, and hide chrome before extraction.

Reach for these tools from simplest to most powerful:

- `adblock` — keep the default `true` unless you explicitly need ads or consent flows visible.
- `click` — dismiss banners, open accordions, or switch tabs.
- `scroll` — trigger content that only loads when a section enters the viewport.
- `styles` — hide chrome or adjust layout with CSS before extraction.

## Use scripts, modules, and function only when needed

If CSS and the basic interaction parameters are still not enough, you can inject JavaScript or run a full browser function:

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

### CLI Microlink API example

``` bash
microlink https://microlink.io&data.content.selector=main&data.content.attr=html&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 "data.content.selector=main" \
  -d "data.content.attr=html" \
  -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', {
  data: {
    content: {
      selector: "main",
      attr: "html"
    }
  },
  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",
    "data.content.selector": "main",
    "data.content.attr": "html",
    "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",
  data.content.selector: "main",
  data.content.attr: "html",
  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",
    "data.content.selector" => "main",
    "data.content.attr" => "html",
    "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("data.content.selector", "main")
    q.Set("data.content.attr", "html")
    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', {

  data: {

    content: {

      selector: "main",

      attr: "html"

    }

  },

  meta: false,

  function: "({ page }) => page.evaluate(() => { document.querySelector('header')?.remove() })"

})
```

Use `function` only for last-resort DOM automation. It runs with Puppeteer access before the extraction result is finalized.

The usual progression is:

1.  `styles` when CSS alone can solve it.
2.  `modules` or `scripts` when you need a little JavaScript in the page.
3.  `function` when you need full browser control.

See the [scripts](https://microlink.io/docs/api/parameters/scripts), [modules](https://microlink.io/docs/api/parameters/modules), and [function reference](https://microlink.io/docs/api/parameters/function) docs for the advanced details.

Learn how to shape the final response as JSON or a direct field response in [delivery and response shaping](https://microlink.io/docs/guides/data-extraction/delivery-and-response).