Function: Browser interaction

Microlink functions can interact with a browser.

page is a Puppeteer Page for the URL you asked for:

import createClient from 'microlink.io'

const microlink = createClient()

const scrape = ({ page }) =>
  page.$eval('h1', el => el.textContent.trim())

const result = await microlink.function('https://example.com', scrape)

console.log(result.value) // 'Example Domain'

Start with the high-level helpers before reaching for lower-level APIs:

page.title: Get the document title.
page.$eval: Run a function on the first matching element.
page.$$eval: Run a function on all matching elements.
page.url: Get the URL the page settled on.
page.content: Get the full page HTML.

Any Puppeteer Page method is available.

Two methods extend page:

page.extract: the same rules as data.
page.metadata: the same normalized metadata as meta.

What your function receives

Property	Type	Description
`url`	`string`	The URL you asked for, not the one a redirect settles on. Available without a browser. `page.url()` is the settled one
`page`	Page	The Puppeteer Page for that URL. The page API is supported. page.extract and page.metadata extend it
`response`	HTTPResponse	The response from the implicit page.goto. Only available when the function loads the page in a browser
`headers`	`object`	The request headers used to fetch the target URL
any extra parameter	depends on what you pass	Custom inputs forwarded from the request

Click, wait, and navigate

Puppeteer helpers let you interact with the page before extracting data:

const scrapeAfterClick = ({ page }) =>
  page.click('button.load-more')
    .then(() => page.waitForSelector('.results'))
    .then(() => page.$$eval('.results li', items =>
      items.map(el => el.textContent.trim())
    ))

const result = await microlink.function('https://example.com', scrapeAfterClick)

Replace fixed waits like page.waitForTimeout(3000) with page.waitForSelector or page.waitForNavigation whenever possible — they are faster and more reliable.

Because function is just another Microlink parameter, you can prepare the page before your function runs using scripts, modules, click, or waitForSelector. In the SDK they travel as the third argument of run:

const { value } = await microlink.function(
  'https://microlink.io',
  ({ page }) => page.evaluate('jQuery.fn.jquery'),
  { scripts: 'https://code.jquery.com/jquery-3.5.0.min.js' }
)

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

CLI Microlink API example

microlink https://microlink.io&function='({ page }) => page.evaluate("jQuery.fn.jquery")'&scripts=https://code.jquery.com/jquery-3.5.0.min.js

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://microlink.io" \
  -d "function=(%7B%20page%20%7D)%20%3D%3E%20page.evaluate(%22jQuery.fn.jquery%22)" \
  -d "scripts=https://code.jquery.com/jquery-3.5.0.min.js"

JavaScript Microlink API example

import createClient from 'microlink.io'

const microlink = createClient()

const { value } = await microlink.function(
  'https://microlink.io',
  ({ page }) => page.evaluate("jQuery.fn.jquery"),
  {
    scripts: [
      "https://code.jquery.com/jquery-3.5.0.min.js"
    ]
  }
)

Python Microlink API example

import requests

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

querystring = {
    "url": "https://microlink.io",
    "function": '''({ page }) => page.evaluate("jQuery.fn.jquery")''',
    "scripts": "https://code.jquery.com/jquery-3.5.0.min.js"
}

response = requests.get(url, params=querystring)

print(response.json())

Ruby Microlink API example

require 'uri'
require 'net/http'

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

params = {
  url: "https://microlink.io",
  function: '({ page }) => page.evaluate("jQuery.fn.jquery")',
  scripts: "https://code.jquery.com/jquery-3.5.0.min.js"
}

uri = URI(base_url)
uri.query = URI.encode_www_form(params)

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
response = http.request(request)

puts response.body

PHP Microlink API example

<?php

$baseUrl = "https://api.microlink.io/";

$params = [
    "url" => "https://microlink.io",
    "function" => '({ page }) => page.evaluate("jQuery.fn.jquery")',
    "scripts" => "https://code.jquery.com/jquery-3.5.0.min.js"
];

$query = http_build_query($params);
$url = $baseUrl . '?' . $query;

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET"
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
    echo "cURL Error #: " . $err;
} else {
    echo $response;
}

Golang Microlink API example

package main

import (
    "fmt"
    "net/http"
    "net/url"
    "io"
)

func main() {
    baseURL := "https://api.microlink.io"

    u, err := url.Parse(baseURL)
    if err != nil {
        panic(err)
    }
    fn := `({ page }) => page.evaluate("jQuery.fn.jquery")`

    q := u.Query()
    q.Set("url", "https://microlink.io")
    q.Set("function", fn)
    q.Set("scripts", "https://code.jquery.com/jquery-3.5.0.min.js")
    u.RawQuery = q.Encode()

    req, err := http.NewRequest("GET", u.String(), nil)
    if err != nil {
        panic(err)
    }

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

import createClient from 'microlink.io'

const microlink = createClient()

const { value } = await microlink.function(
  'https://microlink.io',
  ({ page }) => page.evaluate("jQuery.fn.jquery"),
  {
    scripts: [
      "https://code.jquery.com/jquery-3.5.0.min.js"
    ]
  }
)

The scripts parameter injects jQuery before the function runs, making it available inside page.evaluate.