waitUntil

Copy for LLM

View as Markdown

Type:

Default: 'auto'
Values:

'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'

Tell the browser to wait until the target website emits one or more event(s) to consider navigation succeeded.

The events that can be waited are:

auto: A smart combination of 'load' and 'networkidle2'.
load
: It considers navigation successful when the whole page, including all dependent resources such as stylesheets images, have been loaded. In certain cases, it might not happen at all.
domcontentloaded
: It's fired as soon as the page DOM has been loaded, without waiting for resources to finish loading.
networkidle0: It considers navigation successful when the page has had no network activity for half a second. This might never happen if the page is constantly loading multiple resources.
networkidle2: It considers navigation successful when the page has no more then 2 network requests for half a second. This is useful if page runs a long polling in the background.

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

CLI Microlink API example

microlink https://dev.to&screenshot&waitUntil=domcontentloaded

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://dev.to" \
  -d "screenshot=true" \
  -d "waitUntil=domcontentloaded"

JavaScript Microlink API example

import mql from '@microlink/mql'

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

Python Microlink API example

import requests

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

querystring = {
    "url": "https://dev.to",
    "screenshot": "true",
    "waitUntil": "domcontentloaded"
}

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://dev.to",
  screenshot: "true",
  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

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

$params = [
    "url" => "https://dev.to",
    "screenshot" => "true",
    "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

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("screenshot", "true")
    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))
}

import mql from '@microlink/mql'

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

Different arguments work for different pages. When neither of them work, a good solution would be to navigate with 'domcontentloaded' argument and then simply wait for the needed element to appear on page.

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