WorthClient Status API

const res = await fetch('/api/status');
const data = await res.json();

console.log(data.overall.code);
console.log(data.counts.up, '/', data.counts.total, 'services up');

import requests

data = requests.get("https://status.worthclient.com/api/status").json()

print(data["overall"]["code"])
print(data["counts"]["up"], "/", data["counts"]["total"], "services up")

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

var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder(
        URI.create("https://status.worthclient.com/api/status"))
        .GET().build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

package main

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

func main() {
	resp, err := http.Get("https://status.worthclient.com/api/status")
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

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

curl https://status.worthclient.com/api/status

# Compact: without the top-level monitors array
curl "https://status.worthclient.com/api/status?compact=1"

const token = document.cookie.match(/vx_status_csrf=([^;]+)/)?.[1];

const res = await fetch('/api/status/refresh', {
  method: 'POST',
  headers: { 'x-csrf-token': token }
});

const result = await res.json();
console.log(result); // { ok, checked, failed, generatedAt, nextUpdateAt }

import requests

session = requests.Session()
# First request sets the vx_status_csrf cookie
session.get("https://status.worthclient.com/api/auth/csrf")

csrf = session.cookies.get("vx_status_csrf")
result = session.post(
    "https://status.worthclient.com/api/status/refresh",
    headers={"x-csrf-token": csrf},
).json()

print(result)

import java.net.*;
import java.net.http.*;

var cookieManager = new CookieManager();
HttpClient client = HttpClient.newBuilder()
        .cookieHandler(cookieManager)
        .build();

// First request sets the vx_status_csrf cookie
client.send(HttpRequest.newBuilder(
                URI.create("https://status.worthclient.com/api/auth/csrf"))
                .GET().build(),
        HttpResponse.BodyHandlers.discarding());

String csrf = cookieManager.getCookieStore().getCookies().stream()
        .filter(c -> c.getName().equals("vx_status_csrf"))
        .map(HttpCookie::getValue)
        .findFirst().orElse("");

var request = HttpRequest.newBuilder(
                URI.create("https://status.worthclient.com/api/status/refresh"))
        .header("x-csrf-token", csrf)
        .POST(HttpRequest.BodyPublishers.noBody())
        .build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

package main

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

func main() {
	jar, _ := cookiejar.New(nil)
	client := &http.Client{Jar: jar}

	// First request sets the vx_status_csrf cookie
	client.Get("https://status.worthclient.com/api/auth/csrf")

	req, _ := http.NewRequest(http.MethodPost,
		"https://status.worthclient.com/api/status/refresh", nil)

	for _, cookie := range jar.Cookies(req.URL) {
		if cookie.Name == "vx_status_csrf" {
			req.Header.Set("x-csrf-token", cookie.Value)
		}
	}

	resp, _ := client.Do(req)
	defer resp.Body.Close()

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

# The CSRF token lives in the vx_status_csrf cookie.
# Grab it after visiting any page, then send it as a header:
curl -X POST https://status.worthclient.com/api/status/refresh \
  -H "x-csrf-token: $CSRF_TOKEN" \
  -b "vx_status_csrf=$CSRF_TOKEN"

const { monitors } = await fetch('/api/status/monitors').then((r) => r.json());

for (const monitor of monitors) {
  console.log(`${monitor.name}: ${monitor.status} (${monitor.stats?.uptime30d ?? 'n/a'}% 30d)`);
}

import requests

monitors = requests.get("https://status.worthclient.com/api/status/monitors").json()["monitors"]

for monitor in monitors:
    uptime = monitor["stats"]["uptime30d"] or "n/a"
    print(f"{monitor['name']}: {monitor['status']} ({uptime}% 30d)")

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

var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder(
        URI.create("https://status.worthclient.com/api/status/monitors"))
        .GET().build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

package main

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

type Monitor struct {
	Name   string `json:"name"`
	Status string `json:"status"`
	Stats  struct {
		Uptime30d *float64 `json:"uptime30d"`
	} `json:"stats"`
}

func main() {
	resp, _ := http.Get("https://status.worthclient.com/api/status/monitors")
	defer resp.Body.Close()

	var payload struct {
		Monitors []Monitor `json:"monitors"`
	}
	json.NewDecoder(resp.Body).Decode(&payload)

	for _, monitor := range payload.Monitors {
		fmt.Println(monitor.Name, monitor.Status)
	}
}

curl https://status.worthclient.com/api/status/monitors

const MONITOR_ID = '01j1f2a3b4c5d6e7f8a9b0c2e';

const { monitor } = await fetch(`/api/status/monitors/${MONITOR_ID}`).then((r) => r.json());

console.log(monitor.stats.uptime90d);   // 90-day uptime percentage
console.log(monitor.checks[0]);         // most recent check

import requests

monitor_id = "01j1f2a3b4c5d6e7f8a9b0c2e"
monitor = requests.get(
    f"https://status.worthclient.com/api/status/monitors/{monitor_id}"
).json()["monitor"]

print(monitor["stats"]["uptime90d"])
print(monitor["checks"][0])

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

String monitorId = "01j1f2a3b4c5d6e7f8a9b0c2e";

var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder(URI.create(
        "https://status.worthclient.com/api/status/monitors/" + monitorId))
        .GET().build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

package main

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

func main() {
	const monitorID = "01j1f2a3b4c5d6e7f8a9b0c2e"

	resp, err := http.Get(
		"https://status.worthclient.com/api/status/monitors/" + monitorID)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

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

curl https://status.worthclient.com/api/status/monitors/01j1f2a3b4c5d6e7f8a9b0c2e

const MONITOR_ID = '01j1f2a3b4c5d6e7f8a9b0c2e';

const chart = await fetch(`/api/status/monitors/${MONITOR_ID}/chart?period=d7`)
  .then((r) => r.json());

console.log(chart.period, chart.bucketSeconds, 's buckets');
console.log(chart.buckets.filter((b) => b.value !== null).length, 'samples');

import requests

monitor_id = "01j1f2a3b4c5d6e7f8a9b0c2e"
chart = requests.get(
    f"https://status.worthclient.com/api/status/monitors/{monitor_id}/chart",
    params={"period": "d7"},
).json()

print(chart["period"], chart["bucketSeconds"])
print(len([b for b in chart["buckets"] if b["value"] is not None]), "samples")

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

String monitorId = "01j1f2a3b4c5d6e7f8a9b0c2e";

var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder(URI.create(
        "https://status.worthclient.com/api/status/monitors/" + monitorId
        + "/chart?period=d7"))
        .GET().build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

package main

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

func main() {
	const monitorID = "01j1f2a3b4c5d6e7f8a9b0c2e"

	resp, _ := http.Get(
		"https://status.worthclient.com/api/status/monitors/" + monitorID + "/chart?period=d7")
	defer resp.Body.Close()

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

curl "https://status.worthclient.com/api/status/monitors/01j1f2a3b4c5d6e7f8a9b0c2e/chart?period=d7"

const { incidents } = await fetch('/api/status/incidents').then((r) => r.json());

const active = incidents.filter((i) => i.status !== 'resolved');
console.log(`${active.length} active incident(s)`);
console.log(incidents[0]?.title);

import requests

incidents = requests.get("https://status.worthclient.com/api/status/incidents").json()["incidents"]

active = [i for i in incidents if i["status"] != "resolved"]
print(len(active), "active incident(s)")
print(incidents[0]["title"] if incidents else "none")

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

var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder(
        URI.create("https://status.worthclient.com/api/status/incidents"))
        .GET().build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

package main

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

func main() {
	resp, _ := http.Get("https://status.worthclient.com/api/status/incidents")
	defer resp.Body.Close()

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

curl https://status.worthclient.com/api/status/incidents

const INCIDENT_ID = '01j1f2a3b4c5d6e7f8a9b0c3f';

const { incident } = await fetch(`/api/status/incidents/${INCIDENT_ID}`).then((r) => r.json());

for (const update of incident.updates) {
  console.log(update.created_at, update.status, '-', update.message);
}

import requests

incident_id = "01j1f2a3b4c5d6e7f8a9b0c3f"
incident = requests.get(
    f"https://status.worthclient.com/api/status/incidents/{incident_id}"
).json()["incident"]

for update in incident["updates"]:
    print(update["created_at"], update["status"], "-", update["message"])

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

String incidentId = "01j1f2a3b4c5d6e7f8a9b0c3f";

var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder(URI.create(
        "https://status.worthclient.com/api/status/incidents/" + incidentId))
        .GET().build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

package main

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

func main() {
	const incidentID = "01j1f2a3b4c5d6e7f8a9b0c3f"

	resp, _ := http.Get(
		"https://status.worthclient.com/api/status/incidents/" + incidentID)
	defer resp.Body.Close()

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

curl https://status.worthclient.com/api/status/incidents/01j1f2a3b4c5d6e7f8a9b0c3f

const { maintenance } = await fetch('/api/status/maintenance').then((r) => r.json());

const upcoming = maintenance.filter((m) => m.status === 'scheduled');
console.log(`${upcoming.length} scheduled window(s)`);
console.log(upcoming[0]?.starts_at);

import requests

maintenance = requests.get("https://status.worthclient.com/api/status/maintenance").json()["maintenance"]

upcoming = [m for m in maintenance if m["status"] == "scheduled"]
print(len(upcoming), "scheduled window(s)")
print(upcoming[0]["starts_at"] if upcoming else "none")

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

var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder(
        URI.create("https://status.worthclient.com/api/status/maintenance"))
        .GET().build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

package main

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

func main() {
	resp, _ := http.Get("https://status.worthclient.com/api/status/maintenance")
	defer resp.Body.Close()

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

curl https://status.worthclient.com/api/status/maintenance

const MAINTENANCE_ID = '01j1f2a3b4c5d6e7f8a9b0c4g';

const { maintenance } = await fetch(`/api/status/maintenance/${MAINTENANCE_ID}`).then((r) => r.json());

console.log(maintenance.title, maintenance.status);
console.log(maintenance.starts_at, '->', maintenance.ends_at);

import requests

maintenance_id = "01j1f2a3b4c5d6e7f8a9b0c4g"
maintenance = requests.get(
    f"https://status.worthclient.com/api/status/maintenance/{maintenance_id}"
).json()["maintenance"]

print(maintenance["title"], maintenance["status"])
print(maintenance["starts_at"], "->", maintenance["ends_at"])

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

String maintenanceId = "01j1f2a3b4c5d6e7f8a9b0c4g";

var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder(URI.create(
        "https://status.worthclient.com/api/status/maintenance/" + maintenanceId))
        .GET().build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

package main

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

func main() {
	const maintenanceID = "01j1f2a3b4c5d6e7f8a9b0c4g"

	resp, _ := http.Get(
		"https://status.worthclient.com/api/status/maintenance/" + maintenanceID)
	defer resp.Body.Close()

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

curl https://status.worthclient.com/api/status/maintenance/01j1f2a3b4c5d6e7f8a9b0c4g