Modify primary traffic allowance

PUT/servers/{serverId}/modify/traffic

Set the monthly traffic allowance in GB, 0 for unlimited, and optionally the server's traffic policy overrides. Fields left out are unchanged.

Try it

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

Path params

serverIdrequired

Body application/json

PUT⌘↵

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

Body Paramsapplication/json#

Allowance and policy overrides. Only the fields present are changed.

object

trafficinteger#

Allowance in GB, range 0 - 999999998, 0 = unlimited. Optional when a policy field is sent.

trafficCountDirectioninteger#

Which direction counts towards the allowance.

Value	Meaning
`0`	Inherit from the hypervisor, then the global setting
`1`	Inbound and outbound
`2`	Inbound only
`3`	Outbound only

Allowed values:0123

Since 7.1.0

trafficLimitActioninteger#nullable

What happens when the allowance is reached.

Value	Meaning
`1`	Nothing
`2`	Throttle the network
`null`	Inherit

Allowed values:12null

Since 7.1.0

trafficLimitThrottleIninteger#nullable

Inbound throttle speed in kB/s applied while over the allowance. 0 or more. null inherits.

Since 7.1.0

trafficLimitThrottleOutinteger#nullable

Outbound throttle speed in kB/s. 0 or more. null inherits.

Since 7.1.0

trafficLimitNotification1integer#nullable

First usage alert as a percentage of the allowance. The same steps as the virtualization settings; 0 sends no alert at this level. null inherits.

Allowed values:050607080null

Since 7.1.0

trafficLimitNotification2integer#nullable

Second usage alert as a percentage of the allowance. The same steps as the virtualization settings; 0 sends no alert at this level. null inherits.

Allowed values:0859095null

Since 7.1.0

Examples

{
    "traffic": 1000
}

{
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80
}

{
    "trafficCountDirection": 0,
    "trafficLimitAction": null,
    "trafficLimitThrottleIn": null,
    "trafficLimitThrottleOut": null,
    "trafficLimitNotification1": null,
    "trafficLimitNotification2": null
}

Request Code Samples

Showing the Set the allowance only example from Body Params.

curl --location --request PUT 'https://cp.domain.com/api/v1/servers/69/modify/traffic' \
--header 'Authorization: Bearer <token>' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--data-raw '{
    "traffic": 1000
}'wget --quiet --output-document=- \
  --method=PUT \
  --header='Authorization: Bearer <token>' \
  --header='Accept: application/json' \
  --header='Content-Type: application/json' \
  --body-data='{
    "traffic": 1000
}' \
  'https://cp.domain.com/api/v1/servers/69/modify/traffic'http PUT 'https://cp.domain.com/api/v1/servers/69/modify/traffic' \
  'Authorization: Bearer <token>' \
  'Accept: application/json' \
  'Content-Type: application/json' <<< '{
    "traffic": 1000
}'

const response = await fetch("https://cp.domain.com/api/v1/servers/69/modify/traffic", {
    method: "PUT",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    body: JSON.stringify({
        "traffic": 1000
    }),
});

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

const response = await axios({
    method: "put",
    url: "https://cp.domain.com/api/v1/servers/69/modify/traffic",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    data: {
        "traffic": 1000
    },
});

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

const https = require("https");

const payload = JSON.stringify({
    "traffic": 1000
});

const req = https.request({
    hostname: "cp.domain.com",
    path: "/api/v1/servers/69/modify/traffic",
    method: "PUT",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
        "Content-Length": Buffer.byteLength(payload),
    },
}, (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.write(payload);
req.end();

import requests

url = "https://cp.domain.com/api/v1/servers/69/modify/traffic"
headers = {
    "Authorization": "Bearer <token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
payload = {
    "traffic": 1000,
}

response = requests.request("PUT", url, headers=headers, json=payload)

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",
    "Content-Type": "application/json",
}
payload = json.dumps({
    "traffic": 1000,
})

conn.request("PUT", "/api/v1/servers/69/modify/traffic", payload, 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/modify/traffic',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_POSTFIELDS => json_encode([
        'traffic' => 1000,
    ]),
    CURLOPT_HTTPHEADER => array(
        'Authorization: Bearer <token>',
        'Accept: application/json',
        'Content-Type: 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('PUT', 'https://cp.domain.com/api/v1/servers/69/modify/traffic', [
    'headers' => [
        'Authorization' => 'Bearer <token>',
        'Accept' => 'application/json',
    ],
    'json' => [
        'traffic' => 1000,
    ],
]);

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

package main

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

func main() {
    url := "https://cp.domain.com/api/v1/servers/69/modify/traffic"
    payload := strings.NewReader(`{
    "traffic": 1000
}`)
    req, _ := http.NewRequest("PUT", url, payload)
    req.Header.Add("Authorization", "Bearer <token>")
    req.Header.Add("Accept", "application/json")
    req.Header.Add("Content-Type", "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/modify/traffic"))
            .header("Authorization", "Bearer <token>")
            .header("Accept", "application/json")
            .header("Content-Type", "application/json")
            .method("PUT", HttpRequest.BodyPublishers.ofString("{\"traffic\":1000}"))
            .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();

        MediaType json = MediaType.get("application/json");
        RequestBody body = RequestBody.create("{\"traffic\":1000}", json);

        Request request = new Request.Builder()
            .url("https://cp.domain.com/api/v1/servers/69/modify/traffic")
            .method("PUT", body)
            .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("PUT"), "https://cp.domain.com/api/v1/servers/69/modify/traffic");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "<token>");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
request.Content = new StringContent("{\"traffic\":1000}", Encoding.UTF8, "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/modify/traffic")
request = Net::HTTP::Put.new(uri)
request["Authorization"] = "Bearer <token>"
request["Accept"] = "application/json"
request["Content-Type"] = "application/json"
request.body = "{\"traffic\":1000}"

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/modify/traffic")!)
request.httpMethod = "PUT"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Accept")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = "{\"traffic\":1000}".data(using: .utf8)

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::PUT, "https://cp.domain.com/api/v1/servers/69/modify/traffic")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .body(r#"{
    "traffic": 1000
}"#)
        .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::PUT, "https://cp.domain.com/api/v1/servers/69/modify/traffic")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .body(r#"{
    "traffic": 1000
}"#)
        .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
import okhttp3.RequestBody.Companion.toRequestBody

fun main() {
    val client = OkHttpClient()
    val body = """{
    "traffic": 1000
}""".toRequestBody("application/json".toMediaType())
    val request = Request.Builder()
        .url("https://cp.domain.com/api/v1/servers/69/modify/traffic")
        .method("PUT", body)
        .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('PUT', Uri.parse('https://cp.domain.com/api/v1/servers/69/modify/traffic'));
  request.headers['Authorization'] = 'Bearer <token>';
  request.headers['Accept'] = 'application/json';
  request.headers['Content-Type'] = 'application/json';
  request.body = r'''{
    "traffic": 1000
}''';

  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");
    headers = curl_slist_append(headers, "Content-Type: application/json");

    curl_easy_setopt(curl, CURLOPT_URL, "https://cp.domain.com/api/v1/servers/69/modify/traffic");
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "{\"traffic\":1000}");

    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"
}

$body = @'
{
    "traffic": 1000
}
'@

$response = Invoke-RestMethod -Uri "https://cp.domain.com/api/v1/servers/69/modify/traffic" -Method PUT -Headers $headers -ContentType "application/json" -Body $body
$response | ConvertTo-Json -Depth 10

PUT /api/v1/servers/69/modify/traffic HTTP/1.1
Host: cp.domain.com
Authorization: Bearer <token>
Accept: application/json
Content-Type: application/json
Content-Length: 23

{
    "traffic": 1000
}

curl --location --request PUT 'https://cp.domain.com/api/v1/servers/69/modify/traffic' \
--header 'Authorization: Bearer <token>' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--data-raw '{
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80
}'wget --quiet --output-document=- \
  --method=PUT \
  --header='Authorization: Bearer <token>' \
  --header='Accept: application/json' \
  --header='Content-Type: application/json' \
  --body-data='{
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80
}' \
  'https://cp.domain.com/api/v1/servers/69/modify/traffic'http PUT 'https://cp.domain.com/api/v1/servers/69/modify/traffic' \
  'Authorization: Bearer <token>' \
  'Accept: application/json' \
  'Content-Type: application/json' <<< '{
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80
}'

const response = await fetch("https://cp.domain.com/api/v1/servers/69/modify/traffic", {
    method: "PUT",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    body: JSON.stringify({
        "trafficLimitAction": 2,
        "trafficLimitThrottleIn": 1000,
        "trafficLimitThrottleOut": 1000,
        "trafficLimitNotification1": 80
    }),
});

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

const response = await axios({
    method: "put",
    url: "https://cp.domain.com/api/v1/servers/69/modify/traffic",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    data: {
        "trafficLimitAction": 2,
        "trafficLimitThrottleIn": 1000,
        "trafficLimitThrottleOut": 1000,
        "trafficLimitNotification1": 80
    },
});

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

const https = require("https");

const payload = JSON.stringify({
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80
});

const req = https.request({
    hostname: "cp.domain.com",
    path: "/api/v1/servers/69/modify/traffic",
    method: "PUT",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
        "Content-Length": Buffer.byteLength(payload),
    },
}, (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.write(payload);
req.end();

import requests

url = "https://cp.domain.com/api/v1/servers/69/modify/traffic"
headers = {
    "Authorization": "Bearer <token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
payload = {
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80,
}

response = requests.request("PUT", url, headers=headers, json=payload)

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",
    "Content-Type": "application/json",
}
payload = json.dumps({
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80,
})

conn.request("PUT", "/api/v1/servers/69/modify/traffic", payload, 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/modify/traffic',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_POSTFIELDS => json_encode([
        'trafficLimitAction' => 2,
        'trafficLimitThrottleIn' => 1000,
        'trafficLimitThrottleOut' => 1000,
        'trafficLimitNotification1' => 80,
    ]),
    CURLOPT_HTTPHEADER => array(
        'Authorization: Bearer <token>',
        'Accept: application/json',
        'Content-Type: 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('PUT', 'https://cp.domain.com/api/v1/servers/69/modify/traffic', [
    'headers' => [
        'Authorization' => 'Bearer <token>',
        'Accept' => 'application/json',
    ],
    'json' => [
        'trafficLimitAction' => 2,
        'trafficLimitThrottleIn' => 1000,
        'trafficLimitThrottleOut' => 1000,
        'trafficLimitNotification1' => 80,
    ],
]);

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

package main

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

func main() {
    url := "https://cp.domain.com/api/v1/servers/69/modify/traffic"
    payload := strings.NewReader(`{
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80
}`)
    req, _ := http.NewRequest("PUT", url, payload)
    req.Header.Add("Authorization", "Bearer <token>")
    req.Header.Add("Accept", "application/json")
    req.Header.Add("Content-Type", "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/modify/traffic"))
            .header("Authorization", "Bearer <token>")
            .header("Accept", "application/json")
            .header("Content-Type", "application/json")
            .method("PUT", HttpRequest.BodyPublishers.ofString("{\"trafficLimitAction\":2,\"trafficLimitThrottleIn\":1000,\"trafficLimitThrottleOut\":1000,\"trafficLimitNotification1\":80}"))
            .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();

        MediaType json = MediaType.get("application/json");
        RequestBody body = RequestBody.create("{\"trafficLimitAction\":2,\"trafficLimitThrottleIn\":1000,\"trafficLimitThrottleOut\":1000,\"trafficLimitNotification1\":80}", json);

        Request request = new Request.Builder()
            .url("https://cp.domain.com/api/v1/servers/69/modify/traffic")
            .method("PUT", body)
            .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("PUT"), "https://cp.domain.com/api/v1/servers/69/modify/traffic");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "<token>");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
request.Content = new StringContent("{\"trafficLimitAction\":2,\"trafficLimitThrottleIn\":1000,\"trafficLimitThrottleOut\":1000,\"trafficLimitNotification1\":80}", Encoding.UTF8, "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/modify/traffic")
request = Net::HTTP::Put.new(uri)
request["Authorization"] = "Bearer <token>"
request["Accept"] = "application/json"
request["Content-Type"] = "application/json"
request.body = "{\"trafficLimitAction\":2,\"trafficLimitThrottleIn\":1000,\"trafficLimitThrottleOut\":1000,\"trafficLimitNotification1\":80}"

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/modify/traffic")!)
request.httpMethod = "PUT"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Accept")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = "{\"trafficLimitAction\":2,\"trafficLimitThrottleIn\":1000,\"trafficLimitThrottleOut\":1000,\"trafficLimitNotification1\":80}".data(using: .utf8)

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::PUT, "https://cp.domain.com/api/v1/servers/69/modify/traffic")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .body(r#"{
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80
}"#)
        .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::PUT, "https://cp.domain.com/api/v1/servers/69/modify/traffic")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .body(r#"{
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80
}"#)
        .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
import okhttp3.RequestBody.Companion.toRequestBody

fun main() {
    val client = OkHttpClient()
    val body = """{
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80
}""".toRequestBody("application/json".toMediaType())
    val request = Request.Builder()
        .url("https://cp.domain.com/api/v1/servers/69/modify/traffic")
        .method("PUT", body)
        .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('PUT', Uri.parse('https://cp.domain.com/api/v1/servers/69/modify/traffic'));
  request.headers['Authorization'] = 'Bearer <token>';
  request.headers['Accept'] = 'application/json';
  request.headers['Content-Type'] = 'application/json';
  request.body = r'''{
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80
}''';

  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");
    headers = curl_slist_append(headers, "Content-Type: application/json");

    curl_easy_setopt(curl, CURLOPT_URL, "https://cp.domain.com/api/v1/servers/69/modify/traffic");
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "{\"trafficLimitAction\":2,\"trafficLimitThrottleIn\":1000,\"trafficLimitThrottleOut\":1000,\"trafficLimitNotification1\":80}");

    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"
}

$body = @'
{
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80
}
'@

$response = Invoke-RestMethod -Uri "https://cp.domain.com/api/v1/servers/69/modify/traffic" -Method PUT -Headers $headers -ContentType "application/json" -Body $body
$response | ConvertTo-Json -Depth 10

PUT /api/v1/servers/69/modify/traffic HTTP/1.1
Host: cp.domain.com
Authorization: Bearer <token>
Accept: application/json
Content-Type: application/json
Content-Length: 141

{
    "trafficLimitAction": 2,
    "trafficLimitThrottleIn": 1000,
    "trafficLimitThrottleOut": 1000,
    "trafficLimitNotification1": 80
}

curl --location --request PUT 'https://cp.domain.com/api/v1/servers/69/modify/traffic' \
--header 'Authorization: Bearer <token>' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--data-raw '{
    "trafficCountDirection": 0,
    "trafficLimitAction": null,
    "trafficLimitThrottleIn": null,
    "trafficLimitThrottleOut": null,
    "trafficLimitNotification1": null,
    "trafficLimitNotification2": null
}'wget --quiet --output-document=- \
  --method=PUT \
  --header='Authorization: Bearer <token>' \
  --header='Accept: application/json' \
  --header='Content-Type: application/json' \
  --body-data='{
    "trafficCountDirection": 0,
    "trafficLimitAction": null,
    "trafficLimitThrottleIn": null,
    "trafficLimitThrottleOut": null,
    "trafficLimitNotification1": null,
    "trafficLimitNotification2": null
}' \
  'https://cp.domain.com/api/v1/servers/69/modify/traffic'http PUT 'https://cp.domain.com/api/v1/servers/69/modify/traffic' \
  'Authorization: Bearer <token>' \
  'Accept: application/json' \
  'Content-Type: application/json' <<< '{
    "trafficCountDirection": 0,
    "trafficLimitAction": null,
    "trafficLimitThrottleIn": null,
    "trafficLimitThrottleOut": null,
    "trafficLimitNotification1": null,
    "trafficLimitNotification2": null
}'

const response = await fetch("https://cp.domain.com/api/v1/servers/69/modify/traffic", {
    method: "PUT",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    body: JSON.stringify({
        "trafficCountDirection": 0,
        "trafficLimitAction": null,
        "trafficLimitThrottleIn": null,
        "trafficLimitThrottleOut": null,
        "trafficLimitNotification1": null,
        "trafficLimitNotification2": null
    }),
});

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

const response = await axios({
    method: "put",
    url: "https://cp.domain.com/api/v1/servers/69/modify/traffic",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    data: {
        "trafficCountDirection": 0,
        "trafficLimitAction": null,
        "trafficLimitThrottleIn": null,
        "trafficLimitThrottleOut": null,
        "trafficLimitNotification1": null,
        "trafficLimitNotification2": null
    },
});

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

const https = require("https");

const payload = JSON.stringify({
    "trafficCountDirection": 0,
    "trafficLimitAction": null,
    "trafficLimitThrottleIn": null,
    "trafficLimitThrottleOut": null,
    "trafficLimitNotification1": null,
    "trafficLimitNotification2": null
});

const req = https.request({
    hostname: "cp.domain.com",
    path: "/api/v1/servers/69/modify/traffic",
    method: "PUT",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
        "Content-Length": Buffer.byteLength(payload),
    },
}, (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.write(payload);
req.end();

import requests

url = "https://cp.domain.com/api/v1/servers/69/modify/traffic"
headers = {
    "Authorization": "Bearer <token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
payload = {
    "trafficCountDirection": 0,
    "trafficLimitAction": None,
    "trafficLimitThrottleIn": None,
    "trafficLimitThrottleOut": None,
    "trafficLimitNotification1": None,
    "trafficLimitNotification2": None,
}

response = requests.request("PUT", url, headers=headers, json=payload)

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",
    "Content-Type": "application/json",
}
payload = json.dumps({
    "trafficCountDirection": 0,
    "trafficLimitAction": None,
    "trafficLimitThrottleIn": None,
    "trafficLimitThrottleOut": None,
    "trafficLimitNotification1": None,
    "trafficLimitNotification2": None,
})

conn.request("PUT", "/api/v1/servers/69/modify/traffic", payload, 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/modify/traffic',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_POSTFIELDS => json_encode([
        'trafficCountDirection' => 0,
        'trafficLimitAction' => null,
        'trafficLimitThrottleIn' => null,
        'trafficLimitThrottleOut' => null,
        'trafficLimitNotification1' => null,
        'trafficLimitNotification2' => null,
    ]),
    CURLOPT_HTTPHEADER => array(
        'Authorization: Bearer <token>',
        'Accept: application/json',
        'Content-Type: 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('PUT', 'https://cp.domain.com/api/v1/servers/69/modify/traffic', [
    'headers' => [
        'Authorization' => 'Bearer <token>',
        'Accept' => 'application/json',
    ],
    'json' => [
        'trafficCountDirection' => 0,
        'trafficLimitAction' => null,
        'trafficLimitThrottleIn' => null,
        'trafficLimitThrottleOut' => null,
        'trafficLimitNotification1' => null,
        'trafficLimitNotification2' => null,
    ],
]);

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

package main

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

func main() {
    url := "https://cp.domain.com/api/v1/servers/69/modify/traffic"
    payload := strings.NewReader(`{
    "trafficCountDirection": 0,
    "trafficLimitAction": null,
    "trafficLimitThrottleIn": null,
    "trafficLimitThrottleOut": null,
    "trafficLimitNotification1": null,
    "trafficLimitNotification2": null
}`)
    req, _ := http.NewRequest("PUT", url, payload)
    req.Header.Add("Authorization", "Bearer <token>")
    req.Header.Add("Accept", "application/json")
    req.Header.Add("Content-Type", "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/modify/traffic"))
            .header("Authorization", "Bearer <token>")
            .header("Accept", "application/json")
            .header("Content-Type", "application/json")
            .method("PUT", HttpRequest.BodyPublishers.ofString("{\"trafficCountDirection\":0,\"trafficLimitAction\":null,\"trafficLimitThrottleIn\":null,\"trafficLimitThrottleOut\":null,\"trafficLimitNotification1\":null,\"trafficLimitNotification2\":null}"))
            .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();

        MediaType json = MediaType.get("application/json");
        RequestBody body = RequestBody.create("{\"trafficCountDirection\":0,\"trafficLimitAction\":null,\"trafficLimitThrottleIn\":null,\"trafficLimitThrottleOut\":null,\"trafficLimitNotification1\":null,\"trafficLimitNotification2\":null}", json);

        Request request = new Request.Builder()
            .url("https://cp.domain.com/api/v1/servers/69/modify/traffic")
            .method("PUT", body)
            .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("PUT"), "https://cp.domain.com/api/v1/servers/69/modify/traffic");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "<token>");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
request.Content = new StringContent("{\"trafficCountDirection\":0,\"trafficLimitAction\":null,\"trafficLimitThrottleIn\":null,\"trafficLimitThrottleOut\":null,\"trafficLimitNotification1\":null,\"trafficLimitNotification2\":null}", Encoding.UTF8, "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/modify/traffic")
request = Net::HTTP::Put.new(uri)
request["Authorization"] = "Bearer <token>"
request["Accept"] = "application/json"
request["Content-Type"] = "application/json"
request.body = "{\"trafficCountDirection\":0,\"trafficLimitAction\":null,\"trafficLimitThrottleIn\":null,\"trafficLimitThrottleOut\":null,\"trafficLimitNotification1\":null,\"trafficLimitNotification2\":null}"

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/modify/traffic")!)
request.httpMethod = "PUT"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Accept")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = "{\"trafficCountDirection\":0,\"trafficLimitAction\":null,\"trafficLimitThrottleIn\":null,\"trafficLimitThrottleOut\":null,\"trafficLimitNotification1\":null,\"trafficLimitNotification2\":null}".data(using: .utf8)

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::PUT, "https://cp.domain.com/api/v1/servers/69/modify/traffic")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .body(r#"{
    "trafficCountDirection": 0,
    "trafficLimitAction": null,
    "trafficLimitThrottleIn": null,
    "trafficLimitThrottleOut": null,
    "trafficLimitNotification1": null,
    "trafficLimitNotification2": null
}"#)
        .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::PUT, "https://cp.domain.com/api/v1/servers/69/modify/traffic")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .body(r#"{
    "trafficCountDirection": 0,
    "trafficLimitAction": null,
    "trafficLimitThrottleIn": null,
    "trafficLimitThrottleOut": null,
    "trafficLimitNotification1": null,
    "trafficLimitNotification2": null
}"#)
        .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
import okhttp3.RequestBody.Companion.toRequestBody

fun main() {
    val client = OkHttpClient()
    val body = """{
    "trafficCountDirection": 0,
    "trafficLimitAction": null,
    "trafficLimitThrottleIn": null,
    "trafficLimitThrottleOut": null,
    "trafficLimitNotification1": null,
    "trafficLimitNotification2": null
}""".toRequestBody("application/json".toMediaType())
    val request = Request.Builder()
        .url("https://cp.domain.com/api/v1/servers/69/modify/traffic")
        .method("PUT", body)
        .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('PUT', Uri.parse('https://cp.domain.com/api/v1/servers/69/modify/traffic'));
  request.headers['Authorization'] = 'Bearer <token>';
  request.headers['Accept'] = 'application/json';
  request.headers['Content-Type'] = 'application/json';
  request.body = r'''{
    "trafficCountDirection": 0,
    "trafficLimitAction": null,
    "trafficLimitThrottleIn": null,
    "trafficLimitThrottleOut": null,
    "trafficLimitNotification1": null,
    "trafficLimitNotification2": null
}''';

  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");
    headers = curl_slist_append(headers, "Content-Type: application/json");

    curl_easy_setopt(curl, CURLOPT_URL, "https://cp.domain.com/api/v1/servers/69/modify/traffic");
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "{\"trafficCountDirection\":0,\"trafficLimitAction\":null,\"trafficLimitThrottleIn\":null,\"trafficLimitThrottleOut\":null,\"trafficLimitNotification1\":null,\"trafficLimitNotification2\":null}");

    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"
}

$body = @'
{
    "trafficCountDirection": 0,
    "trafficLimitAction": null,
    "trafficLimitThrottleIn": null,
    "trafficLimitThrottleOut": null,
    "trafficLimitNotification1": null,
    "trafficLimitNotification2": null
}
'@

$response = Invoke-RestMethod -Uri "https://cp.domain.com/api/v1/servers/69/modify/traffic" -Method PUT -Headers $headers -ContentType "application/json" -Body $body
$response | ConvertTo-Json -Depth 10

PUT /api/v1/servers/69/modify/traffic HTTP/1.1
Host: cp.domain.com
Authorization: Bearer <token>
Accept: application/json
Content-Type: application/json
Content-Length: 217

{
    "trafficCountDirection": 0,
    "trafficLimitAction": null,
    "trafficLimitThrottleIn": null,
    "trafficLimitThrottleOut": null,
    "trafficLimitNotification1": null,
    "trafficLimitNotification2": null
}

Responses

201

The change was applied.

No response body.

401

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

No response body.

404

The server was not found.

application/json

ErrorMessage

msgstring#

Example

{
    "msg": "server not found"
}

422

The request was rejected. Example: The selected traffic limit action is invalid..

application/json

Error

errorsarray[string]#

Example

{
    "errors": [
        "The selected traffic limit action is invalid."
    ]
}

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
}

Changes

7.1.0Accepts the per-server traffic policy fields; traffic may be omitted when a policy field is sent.
7.1.0BreakingAllowance is in decimal GB (1 GB = 1,000,000,000 bytes).