API Documentation

curl https://api.youmonit.com/api/v2/monitors \
  -H "Authorization: Bearer ymk_live_xxxxxxxxxxxxxxxx"

<?php
$ch = curl_init('https://api.youmonit.com/api/v2/monitors');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => ['Authorization: Bearer ymk_live_xxxxxxxxxxxxxxxx'],
]);
$body = curl_exec($ch);
curl_close($ch);

$data = json_decode($body, true);
foreach ($data['monitors'] as $m) {
    printf("%s — %s\n", $m['name'], $m['last_status']);
}

const res = await fetch('https://api.youmonit.com/api/v2/monitors', {
  headers: { Authorization: 'Bearer ymk_live_xxxxxxxxxxxxxxxx' },
});
const { monitors } = await res.json();
monitors.forEach(m => console.log(`${m.name} — ${m.last_status}`));

import requests

res = requests.get(
    "https://api.youmonit.com/api/v2/monitors",
    headers={"Authorization": "Bearer ymk_live_xxxxxxxxxxxxxxxx"},
)
for m in res.json()["monitors"]:
    print(m["name"], "—", m["last_status"])

use strict;
use warnings;
use LWP::UserAgent;
use JSON::PP qw(decode_json);

my $ua  = LWP::UserAgent->new;
my $res = $ua->get(
    'https://api.youmonit.com/api/v2/monitors',
    'Authorization' => 'Bearer ymk_live_xxxxxxxxxxxxxxxx',
);
die $res->status_line unless $res->is_success;

my $data = decode_json($res->decoded_content);
for my $m (@{ $data->{monitors} }) {
    printf "%s — %s\n", $m->{name}, $m->{last_status};
}

require "net/http"
require "json"

uri = URI("https://api.youmonit.com/api/v2/monitors")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer ymk_live_xxxxxxxxxxxxxxxx"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
JSON.parse(res.body)["monitors"].each do |m|
  puts "#{m['name']} — #{m['last_status']}"
end

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.youmonit.com/api/v2/monitors", nil)
	req.Header.Set("Authorization", "Bearer ymk_live_xxxxxxxxxxxxxxxx")

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

	var data struct {
		Monitors []struct {
			Name       string `json:"name"`
			LastStatus string `json:"last_status"`
		} `json:"monitors"`
	}
	json.NewDecoder(res.Body).Decode(&data)
	for _, m := range data.Monitors {
		fmt.Printf("%s — %s\n", m.Name, m.LastStatus)
	}
}

curl -X POST https://api.youmonit.com/api/v2/monitors \
  -H "Authorization: Bearer ymk_live_xxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
        "type": "web",
        "name": "Marketing site",
        "target": "https://example.com",
        "interval_seconds": 300
      }'

<?php
$payload = json_encode([
    'type'             => 'web',
    'name'             => 'Marketing site',
    'target'           => 'https://example.com',
    'interval_seconds' => 300,
]);

$ch = curl_init('https://api.youmonit.com/api/v2/monitors');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => $payload,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer ymk_live_xxxxxxxxxxxxxxxx',
        'Content-Type: application/json',
    ],
]);
$monitor = json_decode(curl_exec($ch), true)['monitor'];
curl_close($ch);
echo "Created monitor #{$monitor['id']}\n";

const res = await fetch('https://api.youmonit.com/api/v2/monitors', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer ymk_live_xxxxxxxxxxxxxxxx',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    type: 'web',
    name: 'Marketing site',
    target: 'https://example.com',
    interval_seconds: 300,
  }),
});
const { monitor } = await res.json();
console.log('Created monitor #' + monitor.id);

import requests

res = requests.post(
    "https://api.youmonit.com/api/v2/monitors",
    headers={"Authorization": "Bearer ymk_live_xxxxxxxxxxxxxxxx"},
    json={
        "type": "web",
        "name": "Marketing site",
        "target": "https://example.com",
        "interval_seconds": 300,
    },
)
print("Created monitor #", res.json()["monitor"]["id"])

use strict;
use warnings;
use LWP::UserAgent;
use JSON::PP qw(encode_json decode_json);

my $ua  = LWP::UserAgent->new;
my $res = $ua->post(
    'https://api.youmonit.com/api/v2/monitors',
    'Authorization' => 'Bearer ymk_live_xxxxxxxxxxxxxxxx',
    'Content-Type'  => 'application/json',
    Content         => encode_json({
        type             => 'web',
        name             => 'Marketing site',
        target           => 'https://example.com',
        interval_seconds => 300,
    }),
);
my $monitor = decode_json($res->decoded_content)->{monitor};
print "Created monitor #", $monitor->{id}, "\n";

require "net/http"
require "json"

uri = URI("https://api.youmonit.com/api/v2/monitors")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer ymk_live_xxxxxxxxxxxxxxxx"
req["Content-Type"]  = "application/json"
req.body = {
  type:             "web",
  name:             "Marketing site",
  target:           "https://example.com",
  interval_seconds: 300,
}.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
puts "Created monitor ##{JSON.parse(res.body)['monitor']['id']}"

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	payload, _ := json.Marshal(map[string]any{
		"type":             "web",
		"name":             "Marketing site",
		"target":           "https://example.com",
		"interval_seconds": 300,
	})

	req, _ := http.NewRequest("POST",
		"https://api.youmonit.com/api/v2/monitors", bytes.NewReader(payload))
	req.Header.Set("Authorization", "Bearer ymk_live_xxxxxxxxxxxxxxxx")
	req.Header.Set("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()

	var data struct {
		Monitor struct {
			ID int `json:"id"`
		} `json:"monitor"`
	}
	json.NewDecoder(res.Body).Decode(&data)
	fmt.Printf("Created monitor #%d\n", data.Monitor.ID)
}

curl -X POST https://api.youmonit.com/api/v2/devices \
  -H "Authorization: Bearer ymk_live_xxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
        "platform":     "ios",
        "push_token":   "d5f2a7...c9",
        "device_name":  "Petr's iPhone 15",
        "app_version":  "1.4.2",
        "os_version":   "iOS 18.2",
        "timezone":     "Europe/Prague",
        "locale":       "en"
      }'

<?php
$ch = curl_init('https://api.youmonit.com/api/v2/devices');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => json_encode([
        'platform'    => 'android',
        'push_token'  => $fcmToken,
        'device_name' => 'Pixel 8',
        'app_version' => '1.4.2',
    ]),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer ymk_live_xxxxxxxxxxxxxxxx',
        'Content-Type: application/json',
    ],
]);
$device = json_decode(curl_exec($ch), true)['device'];
curl_close($ch);
echo "Registered device #{$device['id']} for push\n";

// React Native / Expo / Capacitor: call this after the OS grants push
// permission and the SDK hands you a fresh token.
await fetch('https://api.youmonit.com/api/v2/devices', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer ymk_live_xxxxxxxxxxxxxxxx',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    platform:   Platform.OS,        // 'ios' | 'android'
    push_token: fcmOrApnsToken,
    device_name: Device.modelName,
    app_version: Application.nativeApplicationVersion,
    os_version:  Device.osVersion,
    timezone:    Intl.DateTimeFormat().resolvedOptions().timeZone,
    locale:      Localization.locale,
  }),
});

import requests

requests.post(
    "https://api.youmonit.com/api/v2/devices",
    headers={"Authorization": "Bearer ymk_live_xxxxxxxxxxxxxxxx"},
    json={
        "platform":   "android",
        "push_token": fcm_token,
        "device_name": "Pixel 8",
    },
)

use LWP::UserAgent;
use JSON::PP qw(encode_json);

my $ua = LWP::UserAgent->new;
$ua->post(
    'https://api.youmonit.com/api/v2/devices',
    'Authorization' => 'Bearer ymk_live_xxxxxxxxxxxxxxxx',
    'Content-Type'  => 'application/json',
    Content => encode_json({
        platform    => 'android',
        push_token  => $fcm_token,
        device_name => 'Pixel 8',
    }),
);

require "net/http"
require "json"

uri = URI("https://api.youmonit.com/api/v2/devices")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer ymk_live_xxxxxxxxxxxxxxxx"
req["Content-Type"]  = "application/json"
req.body = { platform: "android", push_token: fcm_token, device_name: "Pixel 8" }.to_json

Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }

package main

import (
	"bytes"
	"encoding/json"
	"net/http"
)

func RegisterDevice(apiKey, fcmToken string) error {
	body, _ := json.Marshal(map[string]any{
		"platform":    "android",
		"push_token":  fcmToken,
		"device_name": "Pixel 8",
	})
	req, _ := http.NewRequest("POST",
		"https://api.youmonit.com/api/v2/devices", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	res.Body.Close()
	return nil
}

# `since` is the cursor from the previous response; `wait=25` parks the
# request server-side until fresh data lands (or 25 s elapse).
curl "https://api.youmonit.com/api/v2/updates?since=1721984561000&wait=25" \
  -H "Authorization: Bearer ymk_live_xxxxxxxxxxxxxxxx"

<?php
$cursor = 0;   // start from now; persist between calls
while (true) {
    $url = 'https://api.youmonit.com/api/v2/updates?wait=25&since=' . $cursor;
    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 35,
        CURLOPT_HTTPHEADER     => ['Authorization: Bearer ymk_live_xxxxxxxxxxxxxxxx'],
    ]);
    $data = json_decode(curl_exec($ch), true);
    curl_close($ch);

    foreach ($data['incidents'] as $i) {
        printf("[%s] %s — %s\n", $i['status'], $i['monitor_name'], $i['first_error']);
    }
    $cursor = $data['cursor'];
}

// Simple recursive long-poll loop for the mobile dashboard.
let cursor = 0;
async function pollUpdates() {
  const res = await fetch(`https://api.youmonit.com/api/v2/updates?wait=25&since=${cursor}`, {
    headers: { Authorization: 'Bearer ymk_live_xxxxxxxxxxxxxxxx' },
  });
  const data = await res.json();
  cursor = data.cursor;
  data.incidents.forEach(i => renderIncident(i));
  data.monitor_updates.forEach(m => refreshTile(m));
  setTimeout(pollUpdates, 0);   // immediate re-poll
}
pollUpdates();

import requests, time

cursor = 0
while True:
    r = requests.get(
        "https://api.youmonit.com/api/v2/updates",
        params={"since": cursor, "wait": 25},
        headers={"Authorization": "Bearer ymk_live_xxxxxxxxxxxxxxxx"},
        timeout=35,
    )
    data = r.json()
    cursor = data["cursor"]
    for i in data["incidents"]:
        print(i["status"], i["monitor_name"], i.get("first_error", ""))

use LWP::UserAgent;
use JSON::PP qw(decode_json);

my $ua = LWP::UserAgent->new(timeout => 35);
my $cursor = 0;
while (1) {
    my $res = $ua->get(
        "https://api.youmonit.com/api/v2/updates?wait=25&since=$cursor",
        'Authorization' => 'Bearer ymk_live_xxxxxxxxxxxxxxxx',
    );
    my $data = decode_json($res->decoded_content);
    $cursor = $data->{cursor};
    for my $i (@{ $data->{incidents} }) {
        printf "[%s] %s — %s\n", $i->{status}, $i->{monitor_name}, $i->{first_error};
    }
}

require "net/http"
require "json"

cursor = 0
loop do
  uri = URI("https://api.youmonit.com/api/v2/updates?wait=25&since=#{cursor}")
  req = Net::HTTP::Get.new(uri)
  req["Authorization"] = "Bearer ymk_live_xxxxxxxxxxxxxxxx"
  res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: 35) { |h| h.request(req) }
  data = JSON.parse(res.body)
  cursor = data["cursor"]
  data["incidents"].each { |i| puts "#{i['status']} #{i['monitor_name']}" }
end

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"time"
)

type update struct {
	Cursor    int64 `json:"cursor"`
	Incidents []struct {
		Status      string `json:"status"`
		MonitorName string `json:"monitor_name"`
		FirstError  string `json:"first_error"`
	} `json:"incidents"`
}

func main() {
	client := &http.Client{Timeout: 35 * time.Second}
	cursor := int64(0)
	for {
		req, _ := http.NewRequest("GET",
			fmt.Sprintf("https://api.youmonit.com/api/v2/updates?wait=25&since=%d", cursor), nil)
		req.Header.Set("Authorization", "Bearer ymk_live_xxxxxxxxxxxxxxxx")
		res, err := client.Do(req)
		if err != nil { continue }

		var u update
		json.NewDecoder(res.Body).Decode(&u)
		res.Body.Close()
		cursor = u.Cursor
		for _, i := range u.Incidents {
			fmt.Printf("[%s] %s — %s\n", i.Status, i.MonitorName, i.FirstError)
		}
	}
}