# timeout

## Table of Contents

- [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)

---

Type:

\<string\> \| \<number\>

\
Default: 30s (free) / 90s (pro)

It sets the maximum quantity of time allowed for the internal request lifecycle over the target [url](https://microlink.io/docs/api/parameters/url).

The default is the maximum time available on your plan. Values above the plan ceiling are capped.

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

### CLI Microlink API example

```bash
microlink https://microlink.io&timeout=10s
```

### cURL Microlink API example

```bash
curl -G "https://api.microlink.io" \
  -d "url=https://microlink.io" \
  -d "timeout=10s"
```

### JavaScript Microlink API example

```javascript
import createClient from 'microlink.io'

const microlink = createClient()

const data = await microlink.metadata('https://microlink.io', {
  timeout: "10s"
})
```

### Python Microlink API example

```python
import requests

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

querystring = {
    "url": "https://microlink.io",
    "timeout": "10s"
}

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",
  timeout: "10s"
}

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",
    "timeout" => "10s"
];

$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://microlink.io")
    q.Set("timeout", "10s")
    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
importcreateClientfrom'microlink.io'

constmicrolink=createClient()

constdata=awaitmicrolink.metadata('https://microlink.io',{

timeout:"10s"

})
```

CLI cURL JavaScript Python Ruby PHP Golang Click to run the code and see the API response

The default value is the maximum time available on your plan: 30 seconds free, 90 seconds pro.

You can specify the value in any of the following human-readable way:

```bash
https://microlink.io&timeout=10s# 10000

https://microlink.io&timeout=10secs# 10000

https://microlink.io&timeout=10second# 10000

https://microlink.io&timeout=10seconds# 10000

https://microlink.io&timeout=10000# 10000
```

It also takes a percentage of your plan budget. Use it to get an answer back before the plan timeout fires, whatever plan the key is on:

```bash
https://microlink.io&timeout=80%25# 80% of the plan budget
```

In a URL, `%` is written `%25`, so `timeout=80%25` reaches the API as `80%`. On pro, a bare `%` is rejected with a 400 before the request reaches the API. The SDKs encode it for you, so there you pass `'80%'`.

`timeout=80%` is 72 seconds on pro and 24 seconds on free. A percentage above 100% is the whole plan budget.