Skip to content
API
GUIDES
MQL
SDK
CARDS

Function: Page interaction

Copy for LLM
|
View as Markdown
Your function receives the full
Puppeteer Page
 object.
Start with the high-level helpers before reaching for lower-level APIs:
const microlink = require('@microlink/function')

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

const fn = microlink(scrape)
const result = await fn('https://example.com')
console.log(result.value) // 'Example Domain'
Other useful page helpers, easier to read and debug than page.evaluate():
  • page.title() — get the document title.
  • page.$eval(selector, fn) — run a function on the first matching element.
  • page.$$eval(selector, fn) — run a function on all matching elements.
  • page.url() — get the current URL.
  • page.content() — get the full page HTML.

What your function receives

PropertyTypeDescription
page
Page
Full Puppeteer access for clicks, waits, evaluation, and navigation. When the function references page, Microlink navigates to the URL in a browser before calling your function
response
HTTPResponse
The response returned by the implicit navigation. Only available when the function uses page
headersobjectThe request headers used to fetch the target URL
any extra parameterdepends on what you passCustom inputs forwarded from the request

Two execution contexts

There are two different places your code can run:
Code runs inGood forCan access
The outer function bodyOrchestration, Puppeteer calls, require(), and response shapingpage, response, forwarded params, and npm packages
page.evaluate(...)Reading or computing values from the live DOM when page helpers are not enoughwindow, document, performance, and page state
Start with Puppeteer helpers such as page.title(), page.$eval(), and page.$$eval(). Reach for page.evaluate(...) only when the logic truly belongs inside the page context:
const microlink = require('@microlink/function')

const getPageInfo = ({ page }) =>
  page.evaluate(() => ({
    heading: document.querySelector('h1')?.textContent?.trim(),
    linkCount: document.querySelectorAll('a').length
  }))

const fn = microlink(getPageInfo)
const result = await fn('https://example.com')
console.log(result.value) // { heading: 'Example Domain', linkCount: 1 }
page.evaluate runs inside the browser page context. You cannot use require() or access outer-function variables inside it.

Click, wait, and navigate

Puppeteer helpers let you interact with the page before extracting data:
const microlink = require('@microlink/function')

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 fn = microlink(scrapeAfterClick)
const result = await fn('https://example.com')
Replace fixed waits like page.waitForTimeout(3000) with page.waitForSelector() or page.waitForNavigation() whenever possible — they are faster and more reliable.

Combine with other parameters

Because function is just another Microlink parameter, you can prepare the page before your function runs using scripts, modules, click, or waitForSelector:

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' & 'meta' 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" \
  -d "meta=false"

JavaScript Microlink API example

import mql from '@microlink/mql'

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

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",
    "meta": "false"
}

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

print(response.json())

Ruby Microlink API example

require 'uri'
require 'net/http'

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

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

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

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

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

puts response.body

PHP Microlink API example

<?php

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

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

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

$curl = curl_init();

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

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

curl_close($curl);

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

Golang Microlink API example

package main

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

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

    u, err := url.Parse(baseURL)
    if err != nil {
        panic(err)
    }
    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")
    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))
}
The scripts parameter injects jQuery before the function runs, making it available inside page.evaluate.

See also