Retrieve OS templates available to a server

GET/servers/{serverId}/templates

Operating system template groups available to the server, filtered by its package and hypervisor.

Try it

Sent from this browser to your panel with your token. Reads live data.

Path params

serverIdrequired

GET⌘↵

Request

Authorization

Provide your bearer token in the Authorization header when making requests to protected resources.
Example: Authorization: Bearer ********************

Path Params#

serverIdinteger#required

A valid server ID as shown in VirtFusion.

Example: 69

Request Code Samples

curl --location --request GET 'https://cp.domain.com/api/v1/servers/69/templates' \
--header 'Authorization: Bearer <token>' \
--header 'Accept: application/json'wget --quiet --output-document=- \
  --method=GET \
  --header='Authorization: Bearer <token>' \
  --header='Accept: application/json' \
  'https://cp.domain.com/api/v1/servers/69/templates'http GET 'https://cp.domain.com/api/v1/servers/69/templates' \
  'Authorization: Bearer <token>' \
  'Accept: application/json'

const response = await fetch("https://cp.domain.com/api/v1/servers/69/templates", {
    method: "GET",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
    },
});

const data = await response.json();
console.log(response.status, data);import axios from "axios";

const response = await axios({
    method: "get",
    url: "https://cp.domain.com/api/v1/servers/69/templates",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
    },
});

console.log(response.status, response.data);

const https = require("https");

const req = https.request({
    hostname: "cp.domain.com",
    path: "/api/v1/servers/69/templates",
    method: "GET",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
    },
}, (res) => {
    let data = "";
    res.on("data", (chunk) => (data += chunk));
    res.on("end", () => console.log(res.statusCode, JSON.parse(data)));
});

req.on("error", (err) => console.error(err));
req.end();

import requests

url = "https://cp.domain.com/api/v1/servers/69/templates"
headers = {
    "Authorization": "Bearer <token>",
    "Accept": "application/json",
}

response = requests.request("GET", url, headers=headers)

print(response.status_code)
print(response.json())import http.client
import json

conn = http.client.HTTPSConnection("cp.domain.com")
headers = {
    "Authorization": "Bearer <token>",
    "Accept": "application/json",
}

conn.request("GET", "/api/v1/servers/69/templates", None, headers)
response = conn.getresponse()

print(response.status)
print(json.loads(response.read()))

<?php

$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://cp.domain.com/api/v1/servers/69/templates',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => array(
        'Authorization: Bearer <token>',
        'Accept: application/json'
    ),
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client();

$response = $client->request('GET', 'https://cp.domain.com/api/v1/servers/69/templates', [
    'headers' => [
        'Authorization' => 'Bearer <token>',
        'Accept' => 'application/json',
    ],
]);

echo $response->getStatusCode() . "\n";
echo $response->getBody();

package main

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

func main() {
    url := "https://cp.domain.com/api/v1/servers/69/templates"
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Add("Authorization", "Bearer <token>")
    req.Header.Add("Accept", "application/json")

    res, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer res.Body.Close()

    body, _ := io.ReadAll(res.Body)
    fmt.Println(res.StatusCode, string(body))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://cp.domain.com/api/v1/servers/69/templates"))
            .header("Authorization", "Bearer <token>")
            .header("Accept", "application/json")
            .method("GET", HttpRequest.BodyPublishers.noBody())
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}import okhttp3.*;

public class Main {
    public static void main(String[] args) throws Exception {
        OkHttpClient client = new OkHttpClient();

        Request request = new Request.Builder()
            .url("https://cp.domain.com/api/v1/servers/69/templates")
            .method("GET", null)
            .addHeader("Authorization", "Bearer <token>")
            .addHeader("Accept", "application/json")
            .build();

        try (Response response = client.newCall(request).execute()) {
            System.out.println(response.code());
            System.out.println(response.body().string());
        }
    }
}

using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(new HttpMethod("GET"), "https://cp.domain.com/api/v1/servers/69/templates");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "<token>");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

var response = await client.SendAsync(request);
Console.WriteLine((int)response.StatusCode);
Console.WriteLine(await response.Content.ReadAsStringAsync());

require "net/http"
require "json"

uri = URI("https://cp.domain.com/api/v1/servers/69/templates")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer <token>"
request["Accept"] = "application/json"

response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts response.code
puts JSON.pretty_generate(JSON.parse(response.body))

import Foundation

var request = URLRequest(url: URL(string: "https://cp.domain.com/api/v1/servers/69/templates")!)
request.httpMethod = "GET"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Accept")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    guard let data = data, error == nil else { print(error ?? "request failed"); return }
    print((response as! HTTPURLResponse).statusCode)
    print(String(data: data, encoding: .utf8) ?? "")
}
task.resume()

// Cargo.toml: reqwest = { version = "0.12", features = ["blocking", "json"] }, serde_json = "1"
use reqwest::blocking::Client;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let response = client
        .request(reqwest::Method::GET, "https://cp.domain.com/api/v1/servers/69/templates")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .send()?;

    println!("{}", response.status());
    let json: serde_json::Value = response.json()?;
    println!("{}", serde_json::to_string_pretty(&json)?);
    Ok(())
}// Cargo.toml: reqwest = { version = "0.12", features = ["json"] }, tokio = { version = "1", features = ["full"] }, serde_json = "1"
use reqwest::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let response = client
        .request(reqwest::Method::GET, "https://cp.domain.com/api/v1/servers/69/templates")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .send()
        .await?;

    println!("{}", response.status());
    let json: serde_json::Value = response.json().await?;
    println!("{}", serde_json::to_string_pretty(&json)?);
    Ok(())
}

import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request

fun main() {
    val client = OkHttpClient()
    val request = Request.Builder()
        .url("https://cp.domain.com/api/v1/servers/69/templates")
        .method("GET", null)
        .addHeader("Authorization", "Bearer <token>")
        .addHeader("Accept", "application/json")
        .build()

    client.newCall(request).execute().use { response ->
        println(response.code)
        println(response.body?.string())
    }
}

// pubspec.yaml: http: ^1.2.0
import 'dart:convert';
import 'package:http/http.dart' as http;

Future<void> main() async {
  final request = http.Request('GET', Uri.parse('https://cp.domain.com/api/v1/servers/69/templates'));
  request.headers['Authorization'] = 'Bearer <token>';
  request.headers['Accept'] = 'application/json';

  final response = await http.Response.fromStream(await request.send());
  print(response.statusCode);
  print(const JsonEncoder.withIndent('  ').convert(jsonDecode(response.body)));
}

#include <stdio.h>
#include <curl/curl.h>

int main(void) {
    CURL *curl = curl_easy_init();
    if (!curl) return 1;

    struct curl_slist *headers = NULL;
    headers = curl_slist_append(headers, "Authorization: Bearer <token>");
    headers = curl_slist_append(headers, "Accept: application/json");

    curl_easy_setopt(curl, CURLOPT_URL, "https://cp.domain.com/api/v1/servers/69/templates");
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

    CURLcode result = curl_easy_perform(curl);
    if (result != CURLE_OK) fprintf(stderr, "%s\n", curl_easy_strerror(result));

    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    return result == CURLE_OK ? 0 : 1;
}

$headers = @{
    Authorization = "Bearer <token>"
    Accept        = "application/json"
}

$response = Invoke-RestMethod -Uri "https://cp.domain.com/api/v1/servers/69/templates" -Method GET -Headers $headers
$response | ConvertTo-Json -Depth 10

GET /api/v1/servers/69/templates HTTP/1.1
Host: cp.domain.com
Authorization: Bearer <token>
Accept: application/json

Responses

200

OK.

application/json

object

dataarray[TemplateGroup]#

TemplateGroup fields

descriptionstring#

namestring#

iconstring#

templatesarray[object]#

item fields

typestring#

descriptionstring#

idinteger#

namestring#

versionstring#

variantstring#nullable

archinteger#

iconstring#

eolboolean#

eol_datestring#

eol_warningboolean#

deploy_typeinteger#

vncboolean#

idinteger#

Example

{
    "data": [
        {
            "name": "Debian",
            "description": "Debian GNU/Linux, is a Linux distribution composed of free and open-source software, developed by the community-supported Debian Project.",
            "icon": "debian_logo.png",
            "templates": [
                {
                    "id": 8,
                    "name": "Debian",
                    "version": "11 (Bullseye)",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using Advanced Package Tool (APT), the main command-line package manager for Debian.",
                    "icon": "debian_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                },
                {
                    "id": 46,
                    "name": "Debian",
                    "version": "12 (Bookworm)",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using Advanced Package Tool (APT), the main command-line package manager for Debian.",
                    "icon": "debian_logo.png",
                    "eol": false,
                    "eol_date": "2024-04-23 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                },
                {
                    "id": 56,
                    "name": "Debian",
                    "version": "12 (Bookworm)",
                    "variant": "Test",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using Advanced Package Tool (APT), the main command-line package manager for Debian.",
                    "icon": "debian_logo.png",
                    "eol": false,
                    "eol_date": "2024-04-23 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": true,
                    "type": "linux"
                }
            ],
            "id": 1
        },
        {
            "name": "CentOS",
            "description": "The CentOS Linux distribution is a stable, predictable, manageable and reproducible platform derived from the sources of Red Hat Enterprise Linux (RHEL).",
            "icon": "centos_logo.png",
            "templates": [
                {
                    "id": 1,
                    "name": "CentOS",
                    "version": "7",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using Yum, the main command-line package manager for CentOS.",
                    "icon": "centos_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                },
                {
                    "id": 2,
                    "name": "CentOS Stream",
                    "version": "9",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Base installation with limited packages. New packages are easily installed using DNF (yum), the main command-line package manager for CentOS.",
                    "icon": "centos_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                }
            ],
            "id": 2
        },
        {
            "name": "Rocky Linux",
            "description": "Rocky Linux is a community enterprise operating system designed to be 100% bug-for-bug compatible with America's top enterprise Linux distribution now that its downstream partner has shifted direction. It is under intensive development by the community. Rocky Linux is led by Gregory Kurtzer, founder of the CentOS project.",
            "icon": "rocky_linux_logo.png",
            "templates": [
                {
                    "id": 7,
                    "name": "Rocky Linux",
                    "version": "8",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using DNF (yum), the main command-line package manager for Rocky Linux.",
                    "icon": "rocky_linux_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                },
                {
                    "id": 13,
                    "name": "Rocky Linux",
                    "version": "9",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using DNF (yum), the main command-line package manager for Rocky Linux.",
                    "icon": "rocky_linux_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                }
            ],
            "id": 3
        },
        {
            "name": "AlmaLinux",
            "description": "AlmaLinux OS is an open-source, community-driven project that intends provide and alternative to the CentOS Stable release. AlmaLinux is an OS that is 1:1 binary compatible with RHEL® 8 and a global collaborative of the developer community, industry, academia and research which build upon this technology to empower humanity.",
            "icon": "almalinux_logo.png",
            "templates": [
                {
                    "id": 6,
                    "name": "AlmaLinux",
                    "version": "8",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using DNF (yum), the main command-line package manager for AlmaLinux.",
                    "icon": "almalinux_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                },
                {
                    "id": 12,
                    "name": "ARM -> AlmaLinux",
                    "version": "9",
                    "variant": "Latest",
                    "arch": 1,
                    "description": "Latest version with base packages. New packages are easily installed using DNF (yum), the main command-line package manager for AlmaLinux.",
                    "icon": "almalinux_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                }
            ],
            "id": 4
        },
        {
            "name": "Ubuntu",
            "description": "The most popular server Linux in the cloud and data centre, you can rely on Ubuntu Server and its five years of guaranteed free upgrades.",
            "icon": "ubuntu_logo.png",
            "templates": [
                {
                    "id": 3,
                    "name": "Ubuntu Server",
                    "version": "20.04 LTS (Focal Fossa)",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using Advanced Package Tool (APT), the main command-line package manager for Ubuntu.",
                    "icon": "ubuntu_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                },
                {
                    "id": 4,
                    "name": "Ubuntu Server",
                    "version": "18.04 LTS (Bionic Beaver)",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using Advanced Package Tool (APT), the main command-line package manager for Ubuntu.",
                    "icon": "ubuntu_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                },
                {
                    "id": 9,
                    "name": "Ubuntu Server",
                    "version": "22.04 LTS (Jammy Jellyfish)",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using Advanced Package Tool (APT), the main command-line package manager for Ubuntu.",
                    "icon": "ubuntu_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                },
                {
                    "id": 49,
                    "name": "Ubuntu Server",
                    "version": "24.04 LTS (Noble Numbat)",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using Advanced Package Tool (APT), the main command-line package manager for Ubuntu.",
                    "icon": "ubuntu_logo.png",
                    "eol": false,
                    "eol_date": "2024-04-25 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                }
            ],
            "id": 5
        },
        {
            "name": "Fedora",
            "description": "Fedora Server is a powerful, flexible operating system that includes the best and latest datacenter technologies. It puts you in control of all your infrastructure and services.",
            "icon": "fedora_logo.png",
            "templates": [
                {
                    "id": 11,
                    "name": "Fedora",
                    "version": "37",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using DNF (yum), the main command-line package manager for Fedora.",
                    "icon": "fedora_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                },
                {
                    "id": 14,
                    "name": "Fedora",
                    "version": "38",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using DNF (yum), the main command-line package manager for Fedora.",
                    "icon": "fedora_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                },
                {
                    "id": 15,
                    "name": "Fedora",
                    "version": "39",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using DNF (yum), the main command-line package manager for Fedora.",
                    "icon": "fedora_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                },
                {
                    "id": 59,
                    "name": "Fedora",
                    "version": "41",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages. New packages are easily installed using DNF (yum), the main command-line package manager for Fedora.",
                    "icon": "fedora_logo.png",
                    "eol": false,
                    "eol_date": "2024-12-18 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                }
            ],
            "id": 6
        },
        {
            "name": "FreeBSD",
            "description": "FreeBSD is an operating system used to power modern servers, desktops, and embedded platforms. A large community has continually developed it for more than thirty years. Its advanced networking, security, and storage features have made FreeBSD the platform of choice for many of the busiest web sites and most pervasive embedded networking and storage devices.",
            "icon": "freebsd_logo.png",
            "templates": [
                {
                    "id": 52,
                    "name": "FreeBSD",
                    "version": "13.3",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages.",
                    "icon": "freebsd_logo.png",
                    "eol": false,
                    "eol_date": "2024-05-15 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "unix"
                },
                {
                    "id": 53,
                    "name": "FreeBSD",
                    "version": "14.0",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages.",
                    "icon": "freebsd_logo.png",
                    "eol": false,
                    "eol_date": "2024-05-15 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "unix"
                },
                {
                    "id": 55,
                    "name": "FreeBSD",
                    "version": "14.2",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages.",
                    "icon": "freebsd_logo.png",
                    "eol": false,
                    "eol_date": "2024-10-20 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": true,
                    "type": "unix"
                },
                {
                    "id": 58,
                    "name": "FreeBSD",
                    "version": "13.2",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "Minimal installation with limited packages.",
                    "icon": "freebsd_logo.png",
                    "eol": false,
                    "eol_date": "2024-12-10 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "unix"
                }
            ],
            "id": 7
        },
        {
            "name": "Other",
            "description": "",
            "icon": "linux_logo.png",
            "templates": [
                {
                    "id": 5,
                    "name": "openSUSE",
                    "version": "Leap 15",
                    "variant": "Minimal",
                    "arch": 1,
                    "description": "openSUSE is a project that serves to promote the use of free and open-source software.<br><br>Minimal installation with limited packages. New packages are easily installed using Zypper, the main command-line package manager for openSUSE.",
                    "icon": "opensuse_logo.png",
                    "eol": false,
                    "eol_date": "2024-03-12 00:00:00",
                    "eol_warning": false,
                    "deploy_type": 1,
                    "vnc": false,
                    "type": "linux"
                }
            ],
            "id": 0
        }
    ]
}

401

The bearer token is missing, invalid, or expired. The response has no body.

No response body.

429

Too many requests. Either the token's requests per minute are used up (see the `X-RateL…

application/json

Too many requests. Either the token's requests per minute are used up (see the X-RateLimit-* headers) or the calling address has failed authentication 10 times in a minute (the body then includes retry_after_seconds). Retry-After gives the seconds to wait.

object

errorsarray[string]#

retry_after_secondsinteger#

Seconds to wait before retrying. Present on the failed-authentication limit only.

Response headers

Retry-Afterinteger

Seconds to wait before retrying.

X-RateLimit-Limitinteger

The token's requests per minute (token limit only).

X-RateLimit-Remaininginteger

Requests left in the current minute (token limit only).

X-RateLimit-Resetinteger

Unix timestamp at which the minute resets (token limit only).

Examples

{
    "errors": [
        "Too Many Requests"
    ]
}

{
    "errors": [
        "Too many authentication attempts. Try again later."
    ],
    "retry_after_seconds": 42
}