Dokumentacja Hot Monitoring API 1.0

Hot Monitoring API umożliwia pobieranie historycznych danych monitoringowych z serwisu hotmnt.pl.

Podstawowe informacje

Komunikacja z API odbywa się po protokole https poprzez wysłanie zapytania typu POST, lub PATCH z wymaganymi przez daną metodę parametrami. Każdy użytkownik posiada login i klucz API.
Autoryzacja - basicAuth: przy każdym zapytaniju musisz wysłać nagłówek: zawierający login i klucz użytkownika.

base64(${login}:${apiKey})

Content-Type: application/x-www-form-urlencoded

Klucz może zostać wygenerowany w Panelu Użytkownika na stronie Ustawienia -> Moje Konto / Klucz API . Klucz jest przypisany do konkretnego użytkownika i nie powinien być udostępniany osobom niepowołanym.

Odpowiedź API zakodowana jest w formacie JSON. Odpowiedź zawsze zawiera informacje o statusie odpowiedzi ResponseCode i treści błędu lub OK w ResponseText. W data zawarte są wszelkie dane zwracane przez wywołaną metodę.

Wszelkie daty zapisane są w polskiej strefie czasowej Europe/Warsaw, tj. UTC+01:00 w formacie yyyy-mm-dd hh:mm:ss. W razie potrzeby strefę czasową można zmienić na stronie Ustawienia -> Moje Konto /Strefa czasowa konta

API URL

https://api.hotmnt.pl/api/v1.0

Kody i opisy statusów odpowiedzi

Hot Monitoring API zwraca kody statusów razem z krótkimi opisami słownymi.

ResponseCode	ResponseText	Objaśnienie	Stan odpowiedzi
-1	Unknown error	Nieznany błąd	400
0	OK	Udane uwierzytelnienie.	200
1	Incorrect authentication	Konieczna jest autoryzacja Basic auth.	401
2	Invalid credentials	Uwierzytelnienie nieudane. Podany hash jest nieprawidłowy.	401
3	Invalid input data	W tym zapytaniu wystąpiły błędy. Zazwyczaj opis błędu można znaleźć w odpowiedzi na to zapytanie.	400
429	Too Many Request	Za dużo żądań w określonym oknie czasowym!	429

Operacja "get-company-info"

Pobiera informacje o koncie.

Metoda

POST

Parametry zapytania

Parametr	Opis	Format	Wymagany
operation.get-company-info	Odpowiedni typ operacji	string	Tak

Parametry odpowiedzi

Parametr	Opis	Format
planName	Nazwa aktualnego planu	string
planExpireAt	Data wygaśnięcia aktualnego planu	string
name	Nazwa firmy	string
description	Pełny opis	string
nip	NIP	int
regon	REGON	int
country	Kraj	string
city	Miasto	string
address	Ulica	string
postCode	Kod pocztowy	string
balance	Saldo	double
consumption	Spożycie dziennie	double
domains.count	Liczba domen	int
domains.working	Liczba monitorów dla domen, które działają poprawnie	int
domains.stopped	Liczba monitorów, które aktualnie są zatrzymane	int
domains.warnings	Liczba problemów wykrytych w tej chwili	int
servers.count	Liczba serwerów	int
servers.working	Liczba monitorów dla serwerów, które działają poprawnie	int
servers.stopped	Liczba monitorów, które aktualnie są zatrzymane	int
servers.warnings	Liczba problemów wykrytych w tej chwili	int
monitorings.count	Liczba monitorów	int
monitorings.type	Typ monitora	string

Przykład zapytania

curl --location 'https://api.hotmnt.pl/api/v1.0' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic dGVzdDpwYXNzd29yZA' \
--data-urlencode 'operation=get-company-info'

<?php
$client = new GuzzleHttp\Client();
$response = $client->request('POST', 'https://api.hotmnt.pl/api/v1.0', [
    'headers' => [
        'Content-Type' => 'application/x-www-form-urlencoded',
        'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
    ],
    'form_params' => [
      'operation' => 'get-company-info',
    ]
]);
echo $response->getBody();

const axios = require('axios');

axios.post('https://api.hotmnt.pl/api/v1.0',{"operation":"get-company-info"}, {
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

import okhttp3.*;

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

        RequestBody formBody = new FormBody.Builder()
                .add("operation=get-company-info")
                .build();

        Request request = new Request.Builder()
                .url("https://api.hotmnt.pl/api/v1.0")
                .addHeader("Content-Type", "application/x-www-form-urlencoded")
                .addHeader("Authorization", "Basic dGVzdDpwYXNzd29yZA")
                .post(formBody)
                .build();

        try {
            Response response = client.newCall(request).execute();
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

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

func main() {

  url := "https://api.hotmnt.pl/api/v1.0"
  method := "POST"

  payload := strings.NewReader("operation=get-company-info")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
  req.Header.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

import requests

url = 'https://api.hotmnt.pl/api/v1.0'
headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
}
payload = 'operation=get-company-info'

response = requests.post(url, headers=headers, data=payload)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.hotmnt.pl/api/v1.0")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/x-www-form-urlencoded"
request["Authorization"] = "dGVzdDpwYXNzd29yZA"
request.body = "operation=get-company-info"

response = http.request(request)
puts response.read_body

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://api.hotmnt.pl/api/v1.0");
request.Headers.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA");

var collection = new List<KeyValuePair<string, string>>();
collection.Add(new("operation", "get-company-info"));

var content = new FormUrlEncodedContent(collection);
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $res = $ua->post(
    'https://api.hotmnt.pl/api/v1.0', [
      'operation' => 'get-company-info',
    ],
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
);

print $res->content;

{ResponseCode: 0,
ResponseText: "OK",
planName: "Pro 12 miesięcy",
planExpireAt: "2024-12-31",
name: "Test",
description: "Test Test",
nip: 1234567,
regon: 7654321,
country: "Poland",
city: "Opole",
address: "Test test test, 1",
postCode: "01-123",
balance: "1345.69639",
consumption: "3.11541",
domains: {{count: "2",
working: "10",
stopped: "2",
warnings: "1"
}
},
servers: {{count: "2",
working: "0",
stopped: "0",
warnings: "0"
}
},
monitorings: {{count: 3,
type: "Certificate"
},
{count: 1,
type: "DNS"
},
{count: 1,
type: "FTP"
},
{count: 2,
type: "Head"
},
{count: 3,
type: "Web"
},
{count: 3,
type: "Whois"
}
}}

Operacja "get-company-projects"

Pobiera informacje o projektach.

Metoda

POST

Parametry zapytania

Parametr	Opis	Format	Wymagany
operation.get-company-projects	Odpowiedni typ operacji	string	Tak

Parametry odpowiedzi

Parametr	Opis	Format
data	Tablica z listą projektów	array

Przykład zapytania

curl --location 'https://api.hotmnt.pl/api/v1.0' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic dGVzdDpwYXNzd29yZA' \
--data-urlencode 'operation=get-company-projects'

<?php
$client = new GuzzleHttp\Client();
$response = $client->request('POST', 'https://api.hotmnt.pl/api/v1.0', [
    'headers' => [
        'Content-Type' => 'application/x-www-form-urlencoded',
        'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
    ],
    'form_params' => [
      'operation' => 'get-company-projects',
    ]
]);
echo $response->getBody();

const axios = require('axios');

axios.post('https://api.hotmnt.pl/api/v1.0',{"operation":"get-company-projects"}, {
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

import okhttp3.*;

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

        RequestBody formBody = new FormBody.Builder()
                .add("operation=get-company-projects")
                .build();

        Request request = new Request.Builder()
                .url("https://api.hotmnt.pl/api/v1.0")
                .addHeader("Content-Type", "application/x-www-form-urlencoded")
                .addHeader("Authorization", "Basic dGVzdDpwYXNzd29yZA")
                .post(formBody)
                .build();

        try {
            Response response = client.newCall(request).execute();
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

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

func main() {

  url := "https://api.hotmnt.pl/api/v1.0"
  method := "POST"

  payload := strings.NewReader("operation=get-company-projects")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
  req.Header.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

import requests

url = 'https://api.hotmnt.pl/api/v1.0'
headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
}
payload = 'operation=get-company-projects'

response = requests.post(url, headers=headers, data=payload)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.hotmnt.pl/api/v1.0")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/x-www-form-urlencoded"
request["Authorization"] = "dGVzdDpwYXNzd29yZA"
request.body = "operation=get-company-projects"

response = http.request(request)
puts response.read_body

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://api.hotmnt.pl/api/v1.0");
request.Headers.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA");

var collection = new List<KeyValuePair<string, string>>();
collection.Add(new("operation", "get-company-projects"));

var content = new FormUrlEncodedContent(collection);
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $res = $ua->post(
    'https://api.hotmnt.pl/api/v1.0', [
      'operation' => 'get-company-projects',
    ],
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
);

print $res->content;

{ResponseCode: 0,
ResponseText: "OK",
data: {"AIST-VANI-ETFB",
"CIST-VONL-AAQB",
"BIST-VMNG-EAPN"
}}

Operacja "get-outages"

Pobieranie listy awarii

Metoda

POST

Parametry zapytania

Parametr	Opis	Format	Wymagany
operation.get-outages	Odpowiedni typ operacji	string	Tak
data.start	Numer rekordu, od którego należy rozpocząć pobieranie danych. min 1	int	Tak
data.limit	Limit ilości zwracanych danych. min 10, max 1000	int	Tak
data.dateFrom	Data "od" pobieranych danych	yyyy-mm-dd	Tak
data.dateTo	Data "do" pobieranych danych	yyyy-mm-dd	Tak
data.type	Wybrany typ danych. Dozwolone typy: "outages" lub "current"	string	Tak
data.projects	Filtrować dane według projektów. Podaj "projectId" przez przecinek	string	Nie
data.monitors	Filtrować dane według monitorów. Podaj "monitorId" przez przecinek	string	Nie
data.domains	Filtrować dane według domen. Podaj "domainID" przez przecinek	string	Nie
data.servers	Filtrować dane według serwerów. Podaj "serverID" przez przecinek	string	Nie

Parametry odpowiedzi

Parametr	Opis	Format
recordsTotal	Suma rekordów	int
page	Bieżąca strona	int
rows	Limit ilości zwracanych danych	int
totalPages	Wszystkie strony	int
data[i].outageId	Identyfikator awarii	int
data[i].isSuccess	Status testu	int
data[i].startedAt	Data i godzina wykrycia awarii	yyyy-mm-dd hh:mm:ss
data[i].endedAt	Data i godzina zakończenia awarii	yyyy-mm-dd hh:mm:ss
data[i].monitorId	Identyfikator monitora, którego awaria dotyczy	int
data[i].monitorName	Nazwa monitora	string
data[i].reasonCode	Kod statusu awarii	int
data[i].reasonDetails	Szczegóły przyczyny awarii	string
data[i].duration	Czas trwania awarii	string
data[i].image	Screenshot awarii	string
data[i].harFile	Plik har zawierający wszystkie dane żądań	string
data[i].headers	Wszystkie nagłówki odpowiedzi	array

Przykład zapytania

curl --location 'https://api.hotmnt.pl/api/v1.0' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic dGVzdDpwYXNzd29yZA' \
--data-urlencode 'operation=get-outages' \
--data-urlencode 'data%5Bstart%5D=1' \
--data-urlencode 'data%5Blimit%5D=50' \
--data-urlencode 'data%5BdateFrom%5D=2023-11-20' \
--data-urlencode 'data%5BdateTo%5D=2023-11-26' \
--data-urlencode 'data%5Btype%5D=outages'

<?php
$client = new GuzzleHttp\Client();
$response = $client->request('POST', 'https://api.hotmnt.pl/api/v1.0', [
    'headers' => [
        'Content-Type' => 'application/x-www-form-urlencoded',
        'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
    ],
    'form_params' => [
      'operation' => 'get-outages',
      'data' => [
    'start' => 1,
    'limit' => 50,
        'dateFrom' => '2023-11-20',
        'dateTo' => '2023-11-26',
        'type' => 'outages',
      ],
    ]
]);
echo $response->getBody();

const axios = require('axios');

axios.post('https://api.hotmnt.pl/api/v1.0',{"operation":"get-outages","data":{"start":1,"limit":50,"dateFrom":"2023-11-20","dateTo":"2023-11-26","type":"outages"}}, {
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

import okhttp3.*;

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

        RequestBody formBody = new FormBody.Builder()
                .add("operation=get-outages&data[start]=1&data[limit]=50&data[dateFrom]=2023-11-20&data[dateTo]=2023-11-26&data[type]=outages")
                .build();

        Request request = new Request.Builder()
                .url("https://api.hotmnt.pl/api/v1.0")
                .addHeader("Content-Type", "application/x-www-form-urlencoded")
                .addHeader("Authorization", "Basic dGVzdDpwYXNzd29yZA")
                .post(formBody)
                .build();

        try {
            Response response = client.newCall(request).execute();
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

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

func main() {

  url := "https://api.hotmnt.pl/api/v1.0"
  method := "POST"

  payload := strings.NewReader("operation=get-outages&data%5Bstart%5D=1&data%5Blimit%5D=50&data%5BdateFrom%5D=2023-11-20&data%5BdateTo%5D=2023-11-26&data%5Btype%5D=outages")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
  req.Header.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

import requests

url = 'https://api.hotmnt.pl/api/v1.0'
headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
}
payload = 'operation=get-outages&data%5Bstart%5D=1&data%5Blimit%5D=50&data%5BdateFrom%5D=2023-11-20&data%5BdateTo%5D=2023-11-26&data%5Btype%5D=outages'

response = requests.post(url, headers=headers, data=payload)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.hotmnt.pl/api/v1.0")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/x-www-form-urlencoded"
request["Authorization"] = "dGVzdDpwYXNzd29yZA"
request.body = "operation=get-outages&data%5Bstart%5D=1&data%5Blimit%5D=50&data%5BdateFrom%5D=2023-11-20&data%5BdateTo%5D=2023-11-26&data%5Btype%5D=outages"

response = http.request(request)
puts response.read_body

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://api.hotmnt.pl/api/v1.0");
request.Headers.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA");

var collection = new List<KeyValuePair<string, string>>();
collection.Add(new("operation", "get-outages"));
collection.Add(new("data[start]", "1"));
collection.Add(new("data[limit]", "50"));
collection.Add(new("data[dateFrom]", "2023-11-20"));
collection.Add(new("data[dateTo]", "2023-11-26"));
collection.Add(new("data[type]", "outages"));

var content = new FormUrlEncodedContent(collection);
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $res = $ua->post(
    'https://api.hotmnt.pl/api/v1.0', [
      'operation' => 'get-outages',
      'data' => [
    'start' => 1,
    'limit' => 50,
        'dateFrom' => '2023-11-20',
        'dateTo' => '2023-11-26',
        'type' => 'outages',
      ],
    ],
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
);

print $res->content;

{ResponseCode: 0,
ResponseText: "OK",
recordsTotal: 3,
page: 1,
rows: 50,
totalPages: 1,
data: {{outageId: 6173,
isSuccess: 1,
startedAt: "2023-11-26 05:19:15",
endedAt: "2023-11-26 05:59:15",
monitorId: "HLDS-OEYS-PSPW",
monitorName: "TEST HOT mnt",
reasonCode: 3,
reasonDetails: "Brak zbieżności tekstu lub frazy (które sprawdzamy) na podanym zasobie",
duration: "40m",
image: "https://dl.hotmnt.pl/*******?token=sueir-Ld-***&file=***.png",
harFile: "https://dl.hotmnt.pl/*******_har.json?token=PK-***&-a&file=***.json",
headers: {{code: 200,
version: "HTTP/1.1 200 OK",
redirect: ,
headers: {Date: "Sun, 26 Nov 2023 05:19:15 GMT",
Content-Type: "text/html; charset=UTF-8",
Transfer-Encoding: "chunked",
Connection: "keep-alive",
Cache-Control: "max-age=0, must-revalidate, private",
expires: "Sun, 26 Nov 2023 05:19:15 GMT"
}
}
}
},
{outageId: 6072,
isSuccess: 1,
startedAt: "2023-11-25 02:28:10",
endedAt: "2023-11-25 02:48:10",
monitorId: "JSWE-KSYC-PPXW",
monitorName: "HOT mnt - test",
reasonCode: 522,
reasonDetails: "522 Error - Connection timed out (Cloudflare)",
duration: "20m",
image: "https://dl.hotmnt.pl/*******?token=u92lr-Pc-***&file=***.png",
harFile: "https://dl.hotmnt.pl/*******_har.json?token=Rk-***&-g&file=***.json",
headers: {{code: 522,
version: "HTTP/1.1 502 Bad Gateway",
redirect: ,
headers: {Date: "Sat, 25 Nov 2023 02:28:10 GMT",
Content-Type: "text/html; charset=UTF-8",
Transfer-Encoding: "chunked",
Connection: "keep-alive",
Cache-Control: "max-age=0, must-revalidate, private",
expires: "Sat, 25 Nov 2023 02:28:10 GMT",
CF-Cache-Status: "DYNAMIC",
Report-To: {endpoints: {{url: "***report***"
}
},
group: "cf-nel",
max_age: 604800
},
NEL: {success_fraction: 0,
report_to: "cf-nel",
max_age: 604800
},
Server: "cloudflare",
CF-RAY: "7b7090c38f8235ca-WAW",
Content-Encoding: "br"
}
}
}
},
{outageId: 5864,
isSuccess: 1,
startedAt: "2023-11-25 02:20:10",
endedAt: "2023-11-25 02:35:10",
monitorId: "HLDS-OEYS-PSPW",
monitorName: "TEST HOT mnt",
reasonCode: 3,
reasonDetails: "Brak zbieżności tekstu lub frazy (które sprawdzamy) na podanym zasobie",
duration: "15m",
image: "https://dl.hotmnt.pl/*******?token=***&file=***.png",
harFile: "https://dl.hotmnt.pl/*******_har.json?token=***&-g&file=***.json",
headers: {{code: 200,
version: "HTTP/1.1 200 OK",
redirect: ,
headers: {Date: "Sat, 25 Nov 2023 02:20:10 GMT",
Content-Type: "text/html; charset=UTF-8",
Transfer-Encoding: "chunked",
Connection: "keep-alive",
Cache-Control: "max-age=0, must-revalidate, private",
expires: "Sat, 25 Nov 2023 02:20:10 GMT"
}
}
}
}
}}

Operacja "get-outage"

Pobiera szczegóły awarii.

Metoda

POST

Parametry zapytania

Parametr	Opis	Format	Wymagany
operation.get-outage	Odpowiedni typ operacji	string	Tak
data.outageId	Identyfikator awarii	int	Tak

Parametry odpowiedzi

Parametr	Opis	Format
data	Opis w dziale "get-outages"	array
tests	Lista ostatnich testów wykonanych w trakcie trwania awarii	array
tests.isSuccess	Status testu	int
tests.reasonCode	Kod statusu awarii	int
tests.reasonDetails	Dodatkowe informacja dot. przyczyny awarii, np. słowo kluczowe, które nie zostało znalezione w kodzie HTML strony	string
tests.responseTime	Czas odpowiedzi	float
tests.date	Data wykonania testu	yyyy-mm-dd hh:mm:ss
notifications	Lista wysłanych powiadomien z powodu awarii	array
notifications.event	Zdarzenie	string
notifications.type	Odbiorca powiadomienia	string
notifications.date	Data wysłania powiadomienia	yyyy-mm-dd hh:mm:ss

Przykład zapytania

curl --location 'https://api.hotmnt.pl/api/v1.0' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic dGVzdDpwYXNzd29yZA' \
--data-urlencode 'operation=get-outage' \
--data-urlencode 'data%5BoutageId%5D=5864'

<?php
$client = new GuzzleHttp\Client();
$response = $client->request('POST', 'https://api.hotmnt.pl/api/v1.0', [
    'headers' => [
        'Content-Type' => 'application/x-www-form-urlencoded',
        'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
    ],
    'form_params' => [
      'operation' => 'get-outage',
      'data' => [
    'outageId' => 5864,
      ],
    ]
]);
echo $response->getBody();

const axios = require('axios');

axios.post('https://api.hotmnt.pl/api/v1.0',{"operation":"get-outage","data":{"outageId":5864}}, {
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

import okhttp3.*;

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

        RequestBody formBody = new FormBody.Builder()
                .add("operation=get-outage&data[outageId]=5864")
                .build();

        Request request = new Request.Builder()
                .url("https://api.hotmnt.pl/api/v1.0")
                .addHeader("Content-Type", "application/x-www-form-urlencoded")
                .addHeader("Authorization", "Basic dGVzdDpwYXNzd29yZA")
                .post(formBody)
                .build();

        try {
            Response response = client.newCall(request).execute();
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

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

func main() {

  url := "https://api.hotmnt.pl/api/v1.0"
  method := "POST"

  payload := strings.NewReader("operation=get-outage&data%5BoutageId%5D=5864")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
  req.Header.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

import requests

url = 'https://api.hotmnt.pl/api/v1.0'
headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
}
payload = 'operation=get-outage&data%5BoutageId%5D=5864'

response = requests.post(url, headers=headers, data=payload)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.hotmnt.pl/api/v1.0")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/x-www-form-urlencoded"
request["Authorization"] = "dGVzdDpwYXNzd29yZA"
request.body = "operation=get-outage&data%5BoutageId%5D=5864"

response = http.request(request)
puts response.read_body

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://api.hotmnt.pl/api/v1.0");
request.Headers.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA");

var collection = new List<KeyValuePair<string, string>>();
collection.Add(new("operation", "get-outage"));
collection.Add(new("data[outageId]", "5864"));

var content = new FormUrlEncodedContent(collection);
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $res = $ua->post(
    'https://api.hotmnt.pl/api/v1.0', [
      'operation' => 'get-outage',
      'data' => [
    'outageId' => 5864,
      ],
    ],
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
);

print $res->content;

{ResponseCode: 0,
ResponseText: "OK",
data: {outageId: 5864,
isSuccess: 1,
startedAt: "2023-11-25 02:20:10",
endedAt: "2023-11-25 02:35:10",
monitorId: "HLDS-OEYS-PSPW",
monitorName: "TEST HOT mnt",
reasonCode: 3,
reasonDetails: "Brak zbieżności tekstu lub frazy (które sprawdzamy) na podanym zasobie",
duration: "15m",
image: "https://dl.hotmnt.pl/*******?token=***&file=***.png",
harFile: "https://dl.hotmnt.pl/*******_har.json?token=***&-g&file=***.json",
headers: {{code: 200,
version: "HTTP/1.1 200 OK",
redirect: ,
headers: {Date: "Sat, 25 Nov 2023 02:20:10 GMT",
Content-Type: "text/html; charset=UTF-8",
Transfer-Encoding: "chunked",
Connection: "keep-alive",
Cache-Control: "max-age=0, must-revalidate, private",
expires: "Sat, 25 Nov 2023 02:20:10 GMT"
}
}
},
tests: {{isSuccess: 0,
reasonCode: 3,
reasonDetails: "Brak zbieżności tekstu lub frazy (które sprawdzamy) na podanym zasobie",
responseTime: 7.213,
date: "2023-11-25 02:20:10"
},
{isSuccess: 0,
reasonCode: 3,
reasonDetails: "Brak zbieżności tekstu lub frazy (które sprawdzamy) na podanym zasobie",
responseTime: 8.218,
date: "2023-11-25 02:25:10"
},
{isSuccess: 0,
reasonCode: 3,
reasonDetails: "Brak zbieżności tekstu lub frazy (które sprawdzamy) na podanym zasobie",
responseTime: 7.71,
date: "2023-11-25 02:30:10"
},
{isSuccess: 0,
reasonCode: 3,
reasonDetails: "Brak zbieżności tekstu lub frazy (które sprawdzamy) na podanym zasobie",
responseTime: 8.101,
date: "2023-11-25 02:35:10"
}
},
notifications: {{event: "Wykryto problem",
type: "Wszystkie wybrane kontakty",
date: "2023-11-25 02:20:10"
},
{event: "Koniec niedostępności",
type: "Wszystkie wybrane kontakty",
date: "2023-11-25 02:35:10"
}
}
}}

Operacja "get-monitors"

Pobiera listę wszystkich monitorów, wraz z podstawowymi informacjami.

Metoda

POST

Parametry zapytania

Parametr	Opis	Format	Wymagany
operation.get-monitors	Odpowiedni typ operacji	string	Tak
data.start	Numer rekordu, od którego należy rozpocząć pobieranie danych. min 1	int	Tak
data.limit	Limit ilości zwracanych danych. min 10, max 1000	int	Tak

Parametry odpowiedzi

Parametr	Opis	Format
data	Tablica z listą pobranych monitorów	array
data.monitorId	Identyfikator monitora	int
data.name	Nazwa monitora	string
data.status	Status monitora. ACTIVE, INACTIVE, DELETED	int
data.type	Typ monitora	string
data.createdAt	Data dodania	yyyy-mm-dd
data.currentErrorDate	Data ostatniego błędu	yyyy-mm-dd hh:mm:ss lub null
data.currentOutageId	Identyfikator aktualnie trwającej awarii	int lub null
data.lastRunDate	Data ostatniego uruchomienia	yyyy-mm-dd hh:mm:ss
data.numOfLaunches	Liczba uruchomień	int

Przykład zapytania

curl --location 'https://api.hotmnt.pl/api/v1.0' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic dGVzdDpwYXNzd29yZA' \
--data-urlencode 'operation=get-outages' \
--data-urlencode 'data%5Bstart%5D=1' \
--data-urlencode 'data%5Blimit%5D=50' \
--data-urlencode 'data%5BdateFrom%5D=2023-11-20' \
--data-urlencode 'data%5BdateTo%5D=2023-11-26' \
--data-urlencode 'data%5Btype%5D=outages'

<?php
$client = new GuzzleHttp\Client();
$response = $client->request('POST', 'https://api.hotmnt.pl/api/v1.0', [
    'headers' => [
        'Content-Type' => 'application/x-www-form-urlencoded',
        'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
    ],
    'form_params' => [
      'operation' => 'get-outages',
      'data' => [
    'start' => 1,
    'limit' => 50,
        'dateFrom' => '2023-11-20',
        'dateTo' => '2023-11-26',
        'type' => 'outages',
      ],
    ]
]);
echo $response->getBody();

const axios = require('axios');

axios.post('https://api.hotmnt.pl/api/v1.0',{"operation":"get-outages","data":{"start":1,"limit":50,"dateFrom":"2023-11-20","dateTo":"2023-11-26","type":"outages"}}, {
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

import okhttp3.*;

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

        RequestBody formBody = new FormBody.Builder()
                .add("operation=get-outages&data[start]=1&data[limit]=50&data[dateFrom]=2023-11-20&data[dateTo]=2023-11-26&data[type]=outages")
                .build();

        Request request = new Request.Builder()
                .url("https://api.hotmnt.pl/api/v1.0")
                .addHeader("Content-Type", "application/x-www-form-urlencoded")
                .addHeader("Authorization", "Basic dGVzdDpwYXNzd29yZA")
                .post(formBody)
                .build();

        try {
            Response response = client.newCall(request).execute();
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

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

func main() {

  url := "https://api.hotmnt.pl/api/v1.0"
  method := "POST"

  payload := strings.NewReader("operation=get-outages&data%5Bstart%5D=1&data%5Blimit%5D=50&data%5BdateFrom%5D=2023-11-20&data%5BdateTo%5D=2023-11-26&data%5Btype%5D=outages")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
  req.Header.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

import requests

url = 'https://api.hotmnt.pl/api/v1.0'
headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
}
payload = 'operation=get-outages&data%5Bstart%5D=1&data%5Blimit%5D=50&data%5BdateFrom%5D=2023-11-20&data%5BdateTo%5D=2023-11-26&data%5Btype%5D=outages'

response = requests.post(url, headers=headers, data=payload)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.hotmnt.pl/api/v1.0")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/x-www-form-urlencoded"
request["Authorization"] = "dGVzdDpwYXNzd29yZA"
request.body = "operation=get-outages&data%5Bstart%5D=1&data%5Blimit%5D=50&data%5BdateFrom%5D=2023-11-20&data%5BdateTo%5D=2023-11-26&data%5Btype%5D=outages"

response = http.request(request)
puts response.read_body

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://api.hotmnt.pl/api/v1.0");
request.Headers.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA");

var collection = new List<KeyValuePair<string, string>>();
collection.Add(new("operation", "get-outages"));
collection.Add(new("data[start]", "1"));
collection.Add(new("data[limit]", "50"));
collection.Add(new("data[dateFrom]", "2023-11-20"));
collection.Add(new("data[dateTo]", "2023-11-26"));
collection.Add(new("data[type]", "outages"));

var content = new FormUrlEncodedContent(collection);
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $res = $ua->post(
    'https://api.hotmnt.pl/api/v1.0', [
      'operation' => 'get-outages',
      'data' => [
    'start' => 1,
    'limit' => 50,
        'dateFrom' => '2023-11-20',
        'dateTo' => '2023-11-26',
        'type' => 'outages',
      ],
    ],
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
);

print $res->content;

{ResponseCode: 0,
ResponseText: "OK",
recordsTotal: 5,
page: 1,
rows: 50,
totalPages: 1,
data: {{monitorId: "EFLK-AYAI-RCKE",
name: "Web Test",
status: "ACTIVE",
type: "Web",
createdAt: "2022-09-24",
currentErrorDate: "null",
currentOutageId: "null",
lastRunDate: "2023-11-30 06:13:21",
numOfLaunches: 10000
},
{monitorId: "EFJP-AYAL-XRKE",
name: "FTP TEST",
status: "ACTIVE",
type: "FTP",
createdAt: "2023-07-26",
currentErrorDate: "null",
currentOutageId: "null",
lastRunDate: "2023-11-30 21:51:24",
numOfLaunches: 20
},
{monitorId: "EFJP-KAUC-XRKE",
name: "HOT MNT - TEST",
status: "ACTIVE",
type: "Head",
createdAt: "2022-11-24",
currentErrorDate: "2023-11-30 04:31:15",
currentOutageId: 7404,
lastRunDate: "2023-11-30 04:51:15",
numOfLaunches: 79
},
{monitorId: "EFJA-PQYD-PRKE",
name: "HOT MNT - SSL",
status: "INACTIVE",
type: "Certificate",
createdAt: "2022-09-24",
currentErrorDate: "null",
currentOutageId: "null",
lastRunDate: "2023-07-22 05:31:05",
numOfLaunches: 407
},
{monitorId: "EFOP-LYQM-ARKE",
name: "HOT MNT - WHOIS",
status: "ACTIVE",
type: "Whois",
createdAt: "2022-09-24",
currentErrorDate: "null",
currentOutageId: "null",
lastRunDate: "2023-11-30 03:47:14",
numOfLaunches: 10000
}
}}

Operacja "update-monitor"

Wznawia lub wstrzymuje monitoring wskazanego monitora

Metoda

PATCH

Parametry zapytania

Parametr	Opis	Format	Wymagany
operation.update-monitor	Odpowiedni typ operacji	string	Tak
data.monitorId	Identyfikator monitora	int	Tak
data.command	Polecenie: "start" lub "pause"	string	Tak

Parametry odpowiedzi

Parametr	Opis	Format
ResponseCode	Kod statusu odpowiedzi	int
ResponseText	Opis słowny statusu odpowiedzi	string

Przykład zapytania

curl --location 'https://api.hotmnt.pl/api/v1.0' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic dGVzdDpwYXNzd29yZA' \
--data-urlencode 'operation=get-outages' \
--data-urlencode 'data%5BmonitorId%5D=EFJP-KAUC-XRKE' \
--data-urlencode 'data%5Bcommand%5D=start'

<?php
$client = new GuzzleHttp\Client();
$response = $client->request('POST', 'https://api.hotmnt.pl/api/v1.0', [
    'headers' => [
        'Content-Type' => 'application/x-www-form-urlencoded',
        'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
    ],
    'form_params' => [
      'operation' => 'get-outages',
      'data' => [
        'monitorId' => 'EFJP-KAUC-XRKE',
        'command' => 'start',
      ],
    ]
]);
echo $response->getBody();

const axios = require('axios');

axios.post('https://api.hotmnt.pl/api/v1.0',{"operation":"get-outages","data":{"monitorId":"EFJP-KAUC-XRKE","command":"start"}}, {
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

import okhttp3.*;

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

        RequestBody formBody = new FormBody.Builder()
                .add("operation=get-outages&data[monitorId]=EFJP-KAUC-XRKE&data[command]=start")
                .build();

        Request request = new Request.Builder()
                .url("https://api.hotmnt.pl/api/v1.0")
                .addHeader("Content-Type", "application/x-www-form-urlencoded")
                .addHeader("Authorization", "Basic dGVzdDpwYXNzd29yZA")
                .post(formBody)
                .build();

        try {
            Response response = client.newCall(request).execute();
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

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

func main() {

  url := "https://api.hotmnt.pl/api/v1.0"
  method := "POST"

  payload := strings.NewReader("operation=get-outages&data%5BmonitorId%5D=EFJP-KAUC-XRKE&data%5Bcommand%5D=start")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
  req.Header.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

import requests

url = 'https://api.hotmnt.pl/api/v1.0'
headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
}
payload = 'operation=get-outages&data%5BmonitorId%5D=EFJP-KAUC-XRKE&data%5Bcommand%5D=start'

response = requests.post(url, headers=headers, data=payload)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.hotmnt.pl/api/v1.0")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/x-www-form-urlencoded"
request["Authorization"] = "dGVzdDpwYXNzd29yZA"
request.body = "operation=get-outages&data%5BmonitorId%5D=EFJP-KAUC-XRKE&data%5Bcommand%5D=start"

response = http.request(request)
puts response.read_body

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://api.hotmnt.pl/api/v1.0");
request.Headers.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA");

var collection = new List<KeyValuePair<string, string>>();
collection.Add(new("operation", "get-outages"));
collection.Add(new("data[monitorId]", "EFJP-KAUC-XRKE"));
collection.Add(new("data[command]", "start"));

var content = new FormUrlEncodedContent(collection);
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $res = $ua->post(
    'https://api.hotmnt.pl/api/v1.0', [
      'operation' => 'get-outages',
      'data' => [
        'monitorId' => 'EFJP-KAUC-XRKE',
        'command' => 'start',
      ],
    ],
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
);

print $res->content;

{ResponseCode: 0,
ResponseText: "OK"}

Operacja "get-data"

Pobiera dane o dostępności i czasie odpowiedzi wskazanego monitora.

Metoda

POST

Parametry zapytania

Parametr	Opis	Format	Wymagany
operation.get-data	Odpowiedni typ operacji	string	Tak
monitorId	Identyfikator monitora	int	Tak
data.start	Numer rekordu, od którego należy rozpocząć pobieranie danych. min 1	int	Tak
data.limit	Limit ilości zwracanych danych. min 10, max 1000	int	Tak
data.dateFrom	Data "od" pobieranych danych	yyyy-mm-dd	Tak
data.dateTo	Data "do" pobieranych danych	yyyy-mm-dd	Tak

Parametry odpowiedzi

Parametr	Opis	Format
data	Tablica z danymi pogrupowanymi wg daty	array
data.date	Data grupy danych	yyyy-mm-dd hh:mm:ss
data.uptime	Dostępność, 0-100%	float
data.responseTime	Czas odpowiedzi, sekundy	float

Przykład zapytania

curl --location 'https://api.hotmnt.pl/api/v1.0' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic dGVzdDpwYXNzd29yZA' \
--data-urlencode 'operation=get-data' \
--data-urlencode 'data%5BmonitorId%5D=EFJP-KAUC-XRKE' \
--data-urlencode 'data%5Bstart%5D=1' \
--data-urlencode 'data%5Blimit%5D=10' \
--data-urlencode 'data%5BdateFrom%5D=2023-11-20' \
--data-urlencode 'data%5BdateTo%5D=2023-11-26'

<?php
$client = new GuzzleHttp\Client();
$response = $client->request('POST', 'https://api.hotmnt.pl/api/v1.0', [
    'headers' => [
        'Content-Type' => 'application/x-www-form-urlencoded',
        'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
    ],
    'form_params' => [
      'operation' => 'get-data',
      'data' => [
        'monitorId' => 'EFJP-KAUC-XRKE',
    'start' => 1,
    'limit' => 10,
        'dateFrom' => '2023-11-20',
        'dateTo' => '2023-11-26',
      ],
    ]
]);
echo $response->getBody();

const axios = require('axios');

axios.post('https://api.hotmnt.pl/api/v1.0',{"operation":"get-data","data":{"monitorId":"EFJP-KAUC-XRKE","start":1,"limit":10,"dateFrom":"2023-11-20","dateTo":"2023-11-26"}}, {
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

import okhttp3.*;

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

        RequestBody formBody = new FormBody.Builder()
                .add("operation=get-data&data[monitorId]=EFJP-KAUC-XRKE&data[start]=1&data[limit]=10&data[dateFrom]=2023-11-20&data[dateTo]=2023-11-26")
                .build();

        Request request = new Request.Builder()
                .url("https://api.hotmnt.pl/api/v1.0")
                .addHeader("Content-Type", "application/x-www-form-urlencoded")
                .addHeader("Authorization", "Basic dGVzdDpwYXNzd29yZA")
                .post(formBody)
                .build();

        try {
            Response response = client.newCall(request).execute();
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

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

func main() {

  url := "https://api.hotmnt.pl/api/v1.0"
  method := "POST"

  payload := strings.NewReader("operation=get-data&data%5BmonitorId%5D=EFJP-KAUC-XRKE&data%5Bstart%5D=1&data%5Blimit%5D=10&data%5BdateFrom%5D=2023-11-20&data%5BdateTo%5D=2023-11-26")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
  req.Header.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

import requests

url = 'https://api.hotmnt.pl/api/v1.0'
headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
}
payload = 'operation=get-data&data%5BmonitorId%5D=EFJP-KAUC-XRKE&data%5Bstart%5D=1&data%5Blimit%5D=10&data%5BdateFrom%5D=2023-11-20&data%5BdateTo%5D=2023-11-26'

response = requests.post(url, headers=headers, data=payload)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.hotmnt.pl/api/v1.0")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/x-www-form-urlencoded"
request["Authorization"] = "dGVzdDpwYXNzd29yZA"
request.body = "operation=get-data&data%5BmonitorId%5D=EFJP-KAUC-XRKE&data%5Bstart%5D=1&data%5Blimit%5D=10&data%5BdateFrom%5D=2023-11-20&data%5BdateTo%5D=2023-11-26"

response = http.request(request)
puts response.read_body

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://api.hotmnt.pl/api/v1.0");
request.Headers.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA");

var collection = new List<KeyValuePair<string, string>>();
collection.Add(new("operation", "get-data"));
collection.Add(new("data[monitorId]", "EFJP-KAUC-XRKE"));
collection.Add(new("data[start]", "1"));
collection.Add(new("data[limit]", "10"));
collection.Add(new("data[dateFrom]", "2023-11-20"));
collection.Add(new("data[dateTo]", "2023-11-26"));

var content = new FormUrlEncodedContent(collection);
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $res = $ua->post(
    'https://api.hotmnt.pl/api/v1.0', [
      'operation' => 'get-data',
      'data' => [
        'monitorId' => 'EFJP-KAUC-XRKE',
    'start' => 1,
    'limit' => 10,
        'dateFrom' => '2023-11-20',
        'dateTo' => '2023-11-26',
      ],
    ],
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
);

print $res->content;

{ResponseCode: 0,
ResponseText: "OK",
recordsTotal: 240,
page: 1,
rows: 10,
totalPages: 24,
data: {{date: "2023-11-20 00:00:00",
uptime: 100,
responseTime: 0.258
},
{date: "2023-11-20 01:00:00",
uptime: 100,
responseTime: 0.268
},
{date: "2023-11-20 02:00:00",
uptime: 100,
responseTime: 0.248
},
{date: "2023-11-20 03:00:00",
uptime: 100,
responseTime: 0.278
},
{date: "2023-11-20 04:00:00",
uptime: 100,
responseTime: 0.251
},
{date: "2023-11-20 05:00:00",
uptime: 100,
responseTime: 0.255
},
{date: "2023-11-20 06:00:00",
uptime: 100,
responseTime: 0.248
},
{date: "2023-11-20 07:00:00",
uptime: 100,
responseTime: 0.249
},
{date: "2023-11-20 08:00:00",
uptime: 100,
responseTime: 0.252
},
{date: "2023-11-20 09:00:00",
uptime: 100,
responseTime: 0.257
}
}}

Operacja "get-domains-list"

Pobiera listę wszystkich domen użytkownika

Metoda

POST

Parametry zapytania

Parametr	Opis	Format	Wymagany
operation.get-domains-list	Odpowiedni typ operacji	string	Tak
data.start	Numer rekordu, od którego należy rozpocząć pobieranie danych. min 1	int	Tak
data.limit	Limit ilości zwracanych danych. min 10, max 1000	int	Tak
data.search	Przeszukuj domeny według adresu URL, używane jest wyszukiwanie LIKE	string	Nie
data.filters	Filtrować dane według projektów. Podaj "projectId" przez przecinek	string	Nie

Parametry odpowiedzi

Parametr	Opis	Format
data	Tablica z listą pobranych domen	array
data.id	Identyfikator domeny	string
data.url	URL domeny	string
data.projects	Identyfikator projektu	string
data.serverId	Identyfikator serwera	string
data.serverIp	IP serwera	string
data.description	Pełny opis	string
data.endedAt	WHOIS data	array
data.endedAt.date	Data wygaśnięcia domeny	yyyy-mm-dd
data.endedAt.days	Dni do wygaśnięcia domeny	int
data.sslEndedAt	SSL data	array
data.sslEndedAt.date	Data wygaśnięcia SSL	yyyy-mm-dd
data.sslEndedAt.days	Dni do wygaśnięcia SSL	int
data.monitorings	Tablica z danymi dla monitorów	array
data.monitorings.total	Liczba monitorów	int
data.monitorings.working	Liczba monitorów dla domeny, które działają poprawnie	int
data.monitorings.stopped	Liczba monitorów, które aktualnie są zatrzymane	int
data.monitorings.warnings	Liczba problemów wykrytych w tej chwili	int

Przykład zapytania

curl --location 'https://api.hotmnt.pl/api/v1.0' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic dGVzdDpwYXNzd29yZA' \
--data-urlencode 'operation=get-domains-list' \
--data-urlencode 'data%5Bstart%5D=1' \
--data-urlencode 'data%5Blimit%5D=50'

<?php
$client = new GuzzleHttp\Client();
$response = $client->request('POST', 'https://api.hotmnt.pl/api/v1.0', [
    'headers' => [
        'Content-Type' => 'application/x-www-form-urlencoded',
        'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
    ],
    'form_params' => [
      'operation' => 'get-domains-list',
      'data' => [
    'start' => 1,
    'limit' => 50,
      ],
    ]
]);
echo $response->getBody();

const axios = require('axios');

axios.post('https://api.hotmnt.pl/api/v1.0',{"operation":"get-domains-list","data":{"start":1,"limit":50}}, {
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

import okhttp3.*;

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

        RequestBody formBody = new FormBody.Builder()
                .add("operation=get-domains-list&data[start]=1&data[limit]=50")
                .build();

        Request request = new Request.Builder()
                .url("https://api.hotmnt.pl/api/v1.0")
                .addHeader("Content-Type", "application/x-www-form-urlencoded")
                .addHeader("Authorization", "Basic dGVzdDpwYXNzd29yZA")
                .post(formBody)
                .build();

        try {
            Response response = client.newCall(request).execute();
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

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

func main() {

  url := "https://api.hotmnt.pl/api/v1.0"
  method := "POST"

  payload := strings.NewReader("operation=get-domains-list&data%5Bstart%5D=1&data%5Blimit%5D=50")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
  req.Header.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

import requests

url = 'https://api.hotmnt.pl/api/v1.0'
headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
}
payload = 'operation=get-domains-list&data%5Bstart%5D=1&data%5Blimit%5D=50'

response = requests.post(url, headers=headers, data=payload)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.hotmnt.pl/api/v1.0")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/x-www-form-urlencoded"
request["Authorization"] = "dGVzdDpwYXNzd29yZA"
request.body = "operation=get-domains-list&data%5Bstart%5D=1&data%5Blimit%5D=50"

response = http.request(request)
puts response.read_body

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://api.hotmnt.pl/api/v1.0");
request.Headers.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA");

var collection = new List<KeyValuePair<string, string>>();
collection.Add(new("operation", "get-domains-list"));
collection.Add(new("data[start]", "1"));
collection.Add(new("data[limit]", "50"));

var content = new FormUrlEncodedContent(collection);
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $res = $ua->post(
    'https://api.hotmnt.pl/api/v1.0', [
      'operation' => 'get-domains-list',
      'data' => [
    'start' => 1,
    'limit' => 50,
      ],
    ],
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
);

print $res->content;

{ResponseCode: 0,
ResponseText: "OK",
recordsTotal: 2,
page: 1,
rows: 10,
totalPages: 1,
data: {{id: "EHWQ-DHPY-ZDLV",
url: "api.hotmnt.pl",
projects: "Test",
serverId: "HYPM-QUYX-EFNZ",
serverIp: "127.0.0.1",
description: "Hot Monitoring API",
endedAt: {date: "2023-12-20",
days: 18
},
sslEndedAt: {date: "2023-12-20",
days: 18
},
monitorings: {total: 0,
working: 0,
stopped: 0,
warnings: 0
}
},
{id: "HYPM-QUYX-EFNL",
url: "hotmnt.pl",
projects: "Test",
serverId: "HYPM-QUYX-EFNZ",
serverIp: "127.0.0.1",
description: "Hot Monitoring",
endedAt: {date: "2023-12-20",
days: 18
},
sslEndedAt: {date: "2023-12-20",
days: 18
},
monitorings: {total: 13,
working: 10,
stopped: 2,
warnings: 1
}
}
}}

Operacja "get-servers-list"

Pobiera listę wszystkich serwerów użytkownika

Metoda

POST

Parametry zapytania

Parametr	Opis	Format	Wymagany
operation.get-servers-list	Odpowiedni typ operacji	string	Tak
data.start	Numer rekordu, od którego należy rozpocząć pobieranie danych. min 1	int	Tak
data.limit	Limit ilości zwracanych danych. min 10, max 1000	int	Tak
data.search	Przeszukuj domeny według adresu URL, używane jest wyszukiwanie LIKE	string	Nie
data.filters	Filtrować dane według projektów. Podaj "projectId" przez przecinek	string	Nie

Parametry odpowiedzi

Parametr	Opis	Format
data	Tablica z listą pobranych serwerów	array
data.id	Identyfikator serwera	string
data.ip	IP serwera	string
data.projects	Identyfikator projektu	string
data.description	Pełny opis	string
data.createdAt	Data dodania	yyyy-mm-dd
data.monitorings	Tablica z danymi dla monitorów	array
data.monitorings.total	Liczba monitorów	int
data.monitorings.working	Liczba monitorów dla serwera, które działają poprawnie	int
data.monitorings.stopped	Liczba monitorów, które aktualnie są zatrzymane	int
data.monitorings.warnings	Liczba problemów wykrytych w tej chwili	int

Przykład zapytania

curl --location 'https://api.hotmnt.pl/api/v1.0' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic dGVzdDpwYXNzd29yZA' \
--data-urlencode 'operation=get-servers-list' \
--data-urlencode 'data%5Bstart%5D=1' \
--data-urlencode 'data%5Blimit%5D=50'

<?php
$client = new GuzzleHttp\Client();
$response = $client->request('POST', 'https://api.hotmnt.pl/api/v1.0', [
    'headers' => [
        'Content-Type' => 'application/x-www-form-urlencoded',
        'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
    ],
    'form_params' => [
      'operation' => 'get-servers-list',
      'data' => [
    'start' => 1,
    'limit' => 50,
      ],
    ]
]);
echo $response->getBody();

const axios = require('axios');

axios.post('https://api.hotmnt.pl/api/v1.0',{"operation":"get-servers-list","data":{"start":1,"limit":50}}, {
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

import okhttp3.*;

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

        RequestBody formBody = new FormBody.Builder()
                .add("operation=get-servers-list&data[start]=1&data[limit]=50")
                .build();

        Request request = new Request.Builder()
                .url("https://api.hotmnt.pl/api/v1.0")
                .addHeader("Content-Type", "application/x-www-form-urlencoded")
                .addHeader("Authorization", "Basic dGVzdDpwYXNzd29yZA")
                .post(formBody)
                .build();

        try {
            Response response = client.newCall(request).execute();
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

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

func main() {

  url := "https://api.hotmnt.pl/api/v1.0"
  method := "POST"

  payload := strings.NewReader("operation=get-servers-list&data%5Bstart%5D=1&data%5Blimit%5D=50")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
  req.Header.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

import requests

url = 'https://api.hotmnt.pl/api/v1.0'
headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
}
payload = 'operation=get-servers-list&data%5Bstart%5D=1&data%5Blimit%5D=50'

response = requests.post(url, headers=headers, data=payload)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.hotmnt.pl/api/v1.0")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/x-www-form-urlencoded"
request["Authorization"] = "dGVzdDpwYXNzd29yZA"
request.body = "operation=get-servers-list&data%5Bstart%5D=1&data%5Blimit%5D=50"

response = http.request(request)
puts response.read_body

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://api.hotmnt.pl/api/v1.0");
request.Headers.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA");

var collection = new List<KeyValuePair<string, string>>();
collection.Add(new("operation", "get-servers-list"));
collection.Add(new("data[start]", "1"));
collection.Add(new("data[limit]", "50"));

var content = new FormUrlEncodedContent(collection);
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $res = $ua->post(
    'https://api.hotmnt.pl/api/v1.0', [
      'operation' => 'get-servers-list',
      'data' => [
    'start' => 1,
    'limit' => 50,
      ],
    ],
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
);

print $res->content;

{ResponseCode: 0,
ResponseText: "OK",
recordsTotal: 3,
page: 1,
rows: 10,
totalPages: 1,
data: {{id: "HYPM-QUYX-EFNZ",
ip: "127.0.0.1",
projects: "Test",
description: "Hot Monitoring",
createdAt: "2023-02-09",
monitorings: {total: 0,
working: 0,
stopped: 0,
warnings: 0
}
},
{id: "OYPL-IUCM-TFNM",
ip: "127.0.0.2",
projects: "Test",
description: "Hot Monitoring Test",
createdAt: "2023-09-11",
monitorings: {total: 0,
working: 0,
stopped: 0,
warnings: 0
}
}
}}

Operacja "get-payments"

Pobiera dane o zamówieniach

Metoda

POST

Parametry zapytania

Parametr	Opis	Format	Wymagany
operation.get-payments	Odpowiedni typ operacji	string	Tak
data.start	Numer rekordu, od którego należy rozpocząć pobieranie danych. min 1	int	Tak
data.limit	Limit ilości zwracanych danych. min 10, max 1000	int	Tak

Parametry odpowiedzi

Parametr	Opis	Format
data	Tablica z listą pobranych zamówień	array
orderId	Zamówienie #	int
createdAt	Data dodania	yyyy-mm-dd hh:mm:ss
processedAt	Data płatności	yyyy-mm-dd hh:mm:ss
amount	Kwota płatności	double
currency	Waluta	string
status	Status	string
description	Opis	string
download	Link do pobrania faktury VAT w formacie PDF	string

Przykład zapytania

curl --location 'https://api.hotmnt.pl/api/v1.0' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic dGVzdDpwYXNzd29yZA' \
--data-urlencode 'operation=get-payments' \
--data-urlencode 'data%5Bstart%5D=1' \
--data-urlencode 'data%5Blimit%5D=10'

<?php
$client = new GuzzleHttp\Client();
$response = $client->request('POST', 'https://api.hotmnt.pl/api/v1.0', [
    'headers' => [
        'Content-Type' => 'application/x-www-form-urlencoded',
        'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
    ],
    'form_params' => [
      'operation' => 'get-payments',
      'data' => [
    'start' => 1,
    'limit' => 10,
      ],
    ]
]);
echo $response->getBody();

const axios = require('axios');

axios.post('https://api.hotmnt.pl/api/v1.0',{"operation":"get-payments","data":{"start":1,"limit":10}}, {
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

import okhttp3.*;

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

        RequestBody formBody = new FormBody.Builder()
                .add("operation=get-payments&data[start]=1&data[limit]=10")
                .build();

        Request request = new Request.Builder()
                .url("https://api.hotmnt.pl/api/v1.0")
                .addHeader("Content-Type", "application/x-www-form-urlencoded")
                .addHeader("Authorization", "Basic dGVzdDpwYXNzd29yZA")
                .post(formBody)
                .build();

        try {
            Response response = client.newCall(request).execute();
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

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

func main() {

  url := "https://api.hotmnt.pl/api/v1.0"
  method := "POST"

  payload := strings.NewReader("operation=get-payments&data%5Bstart%5D=1&data%5Blimit%5D=10")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
  req.Header.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

import requests

url = 'https://api.hotmnt.pl/api/v1.0'
headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': 'Basic dGVzdDpwYXNzd29yZA'
}
payload = 'operation=get-payments&data%5Bstart%5D=1&data%5Blimit%5D=10'

response = requests.post(url, headers=headers, data=payload)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.hotmnt.pl/api/v1.0")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/x-www-form-urlencoded"
request["Authorization"] = "dGVzdDpwYXNzd29yZA"
request.body = "operation=get-payments&data%5Bstart%5D=1&data%5Blimit%5D=10"

response = http.request(request)
puts response.read_body

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://api.hotmnt.pl/api/v1.0");
request.Headers.Add("Authorization", "Basic dGVzdDpwYXNzd29yZA");

var collection = new List<KeyValuePair<string, string>>();
collection.Add(new("operation", "get-payments"));
collection.Add(new("data[start]", "1"));
collection.Add(new("data[limit]", "10"));

var content = new FormUrlEncodedContent(collection);
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $res = $ua->post(
    'https://api.hotmnt.pl/api/v1.0', [
      'operation' => 'get-payments',
      'data' => [
    'start' => 1,
    'limit' => 10,
      ],
    ],
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Authorization' => 'Basic dGVzdDpwYXNzd29yZA'
);

print $res->content;

{ResponseCode: 0,
ResponseText: "OK",
recordsTotal: 107,
page: 1,
rows: 10,
totalPages: 11,
data: {{orderId: "BEVW-JKXK-EMYL",
createdAt: "2023-11-20 04:52:19",
processedAt: "2023-11-20 04:52:19",
amount: 1,
currency: "PLN",
status: "Bonus",
description: "Premia jednorazowa",
download: "null"
},
{orderId: "MAEF-LEJU-QJOL",
createdAt: "2023-11-21 05:34:04",
processedAt: "2023-11-21 05:34:04",
amount: 1,
currency: "PLN",
status: "Bonus",
description: "Premia jednorazowa",
download: "null"
},
{orderId: "JLBK-UZEX-IPRE",
createdAt: "2023-11-22 05:33:48",
processedAt: "2023-11-22 05:33:48",
amount: 1,
currency: "PLN",
status: "Bonus",
description: "Premia jednorazowa",
download: "null"
},
{orderId: "IJHB-JWZE-MREL",
createdAt: "2023-11-23 05:31:49",
processedAt: "2023-11-23 05:31:49",
amount: 1,
currency: "PLN",
status: "Bonus",
description: "Premia jednorazowa",
download: "null"
},
{orderId: "AEVT-MZYD-UNRN",
createdAt: "2023-11-24 05:28:51",
processedAt: "2023-11-24 05:28:51",
amount: 1,
currency: "PLN",
status: "Bonus",
description: "Premia jednorazowa",
download: "null"
},
{orderId: "LXBZ-XDNF-DKXB",
createdAt: "2023-11-25 04:54:12",
processedAt: "2023-11-25 04:54:12",
amount: 1,
currency: "PLN",
status: "Bonus",
description: "Premia jednorazowa",
download: "null"
},
{orderId: "KFSZ-KIXC-OKPT",
createdAt: "2023-11-26 04:45:58",
processedAt: "2023-11-26 04:45:58",
amount: 1,
currency: "PLN",
status: "Bonus",
description: "Premia jednorazowa",
download: "null"
},
{orderId: "FNJB-DDSX-HKXE",
createdAt: "2023-11-27 04:42:40",
processedAt: "2023-11-27 04:42:40",
amount: 1,
currency: "PLN",
status: "Bonus",
description: "Premia jednorazowa",
download: "null"
},
{orderId: "HBVD-CRRE-DFEL",
createdAt: "2023-11-28 06:16:56",
processedAt: "2023-11-28 05:49:21",
amount: 5,
currency: "PLN",
status: "Pomyślnie zapłacono",
description: "test",
download: "https://hotmnt.pl/...../HBVD-CRRE-DFEL"
},
{orderId: "NWJN-BHKM-MXHM",
createdAt: "2023-11-29 05:28:15",
processedAt: "2023-11-29 05:49:21",
amount: 1199,
currency: "PLN",
status: "Pomyślnie zapłacono",
description: "Pro 12",
download: "https://hotmnt.pl/...../NWJN-BHKM-MXHM"
}
}}