## Table of Contents

- [waitUntil](#waituntil)
  - [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)

---

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

## waitUntil

Type:

\<string\> \| \<string\[\]\>

\
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'`.

- [](https://developer.mozilla.org/en-US/docs/Web/API/Window/load_event)

  **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.

- [](https://developer.mozilla.org/en-US/docs/Web/API/Document/DOMContentLoaded_event)

  **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

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

### cURL Microlink API example

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

### JavaScript Microlink API example

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

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

### Python Microlink API example

``` python
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

``` ruby
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
<?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

``` 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("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))
}
```

``` javascript
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:

### CLI Microlink API example

``` bash
microlink https://dev.to&screenshot&waitUntil=domcontentloaded&waitForSelector=h1
```

### cURL Microlink API example

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

### JavaScript Microlink API example

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

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

### Python Microlink API example

``` python
import requests

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

querystring = {
    "url": "https://dev.to",
    "screenshot": "true",
    "waitUntil": "domcontentloaded",
    "waitForSelector": "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",
  screenshot: "true",
  waitUntil: "domcontentloaded",
  waitForSelector: "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",
    "screenshot" => "true",
    "waitUntil" => "domcontentloaded",
    "waitForSelector" => "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("screenshot", "true")
    q.Set("waitUntil", "domcontentloaded")
    q.Set("waitForSelector", "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', {

  screenshot: true,

  waitUntil: "domcontentloaded",

  waitForSelector: "h1"

})
```