GET Read account-wide usage and limits

{
  "active_archive_queries_limit": 2,
  "active_exports_limit": 1,
  "alarms_limit": 0,
  "batch_bytes_limit": 0,
  "batch_items_limit": 0,
  "bytes_per_minute_limit": 0,
  "day_bytes": 0,
  "day_bytes_limit": 0,
  "day_event_bytes": 0,
  "day_event_bytes_limit": 0,
  "day_events": 0,
  "day_events_limit": 0,
  "day_items": 0,
  "day_items_limit": 0,
  "day_notifications": 0,
  "day_points": 0,
  "day_points_limit": 0,
  "devices": 0,
  "devices_limit": 0,
  "events_per_minute_limit": 0,
  "groups": 2,
  "groups_limit": 100,
  "items_per_minute_limit": 0,
  "keys": 0,
  "keys_limit": 0,
  "limits": {
    "active_alarms": 200,
    "active_archive_queries": 2,
    "active_devices": 10,
    "active_exports": 1,
    "active_groups": 100,
    "active_keys": 20,
    "active_series": 200,
    "active_workspaces": 50,
    "alarm_per_minute": 10,
    "batch_bytes": 262144,
    "batch_items": 1000,
    "bytes_per_day": 1073741824,
    "bytes_per_minute": 2097152,
    "device_per_day": 20,
    "device_per_minute": 5,
    "event_bytes_per_day": 10485760,
    "event_per_day": 10000,
    "event_per_minute": 60,
    "group_per_minute": 10,
    "key_per_minute": 5,
    "live_series_per_connection": 32,
    "notifications_per_day": 500,
    "notifications_per_hour": 60,
    "point_per_day": 4000000,
    "point_per_minute": 3000,
    "request_per_minute": 180,
    "series_per_30_days": 500,
    "series_per_minute": 60,
    "workspace_per_minute": 10,
    "log_bytes_per_day": 1073741824
  },
  "limits_version": "0000000000000000000000000000000000000000000000000000000000000000",
  "live_series_per_connection_limit": 32,
  "monitors": 0,
  "monitors_limit": 0,
  "new_devices_per_minute_limit": 0,
  "new_devices_today": 0,
  "new_devices_today_limit": 0,
  "new_keys_per_minute_limit": 0,
  "new_series_30d": 0,
  "new_series_30d_limit": 0,
  "new_series_per_minute_limit": 0,
  "new_workspaces_per_minute_limit": 0,
  "notifications_per_day_limit": 0,
  "notifications_per_hour_limit": 0,
  "points_per_minute_limit": 0,
  "registration_origin": "demo",
  "requests_per_minute_limit": 0,
  "series": 0,
  "series_limit": 0,
  "tier": "demo",
  "workspaces": 0,
  "workspaces_limit": 0,
  "forecast": {
    "monitors": [],
    "other_today": {
      "bytes": 0,
      "event_bytes": 0,
      "events": 0,
      "items": 0
    },
    "planned": {
      "bytes": 0,
      "event_bytes": 0,
      "events": 0,
      "items": 0
    },
    "reset_at": "2026-10-03T00:00:00Z",
    "sampled_at": "2026-10-02T12:00:00Z",
    "truncated": false,
    "workspace_planned": {
      "bytes": 0,
      "event_bytes": 0,
      "events": 0,
      "items": 0
    }
  }
}

{
  "code": "demo",
  "detail": "Demo error detail; inspect the documented code.",
  "instance": "demo",
  "message": "Demo error detail; inspect the documented code.",
  "message_key": "errors.requestFailed",
  "message_params": {},
  "request_id": "00000000000000000000000000000000",
  "status": 401,
  "title": "Demo error",
  "type": "about:blank"
}

{
  "code": "demo",
  "detail": "Demo error detail; inspect the documented code.",
  "instance": "demo",
  "message": "Demo error detail; inspect the documented code.",
  "message_key": "errors.requestFailed",
  "message_params": {},
  "request_id": "00000000000000000000000000000000",
  "status": 403,
  "title": "Demo error",
  "type": "about:blank"
}

{
  "code": "demo",
  "detail": "Demo error detail; inspect the documented code.",
  "instance": "demo",
  "message": "Demo error detail; inspect the documented code.",
  "message_key": "errors.requestFailed",
  "message_params": {},
  "request_id": "00000000000000000000000000000000",
  "status": 503,
  "title": "Demo error",
  "type": "about:blank"
}

{
  "code": "demo",
  "detail": "Demo error detail; inspect the documented code.",
  "instance": "demo",
  "message": "Demo error detail; inspect the documented code.",
  "message_key": "errors.requestFailed",
  "message_params": {},
  "request_id": "00000000000000000000000000000000",
  "status": 422,
  "title": "Demo error",
  "type": "about:blank"
}

curl --silent --show-error --output /dev/null --write-out "%{http_code}\n" \
  --request GET \
  --header @"$HOME/.config/metribeacon/headers.txt" \
  "https://metribeacon.com/api/v1/usage"

import json
from pathlib import Path
from urllib.request import Request, HTTPRedirectHandler, build_opener
from urllib.error import HTTPError

headers = json.loads((Path.home() / ".config/metribeacon/headers.json").read_text())
request = Request("https://metribeacon.com/api/v1/usage", data=None, headers=headers, method="GET")
class NoRedirect(HTTPRedirectHandler):
    def redirect_request(self, request, fp, code, message, headers, target):
        return None

opener = build_opener(NoRedirect())
try:
    with opener.open(request, timeout=10) as response:
        print(response.status)
except HTTPError as error:
    print(error.code)
    error.close()

import { readFile } from "node:fs/promises";
import { homedir } from "node:os";
import { join } from "node:path";

const headers = JSON.parse(await readFile(join(homedir(), ".config/metribeacon/headers.json"), "utf8"));
const response = await fetch("https://metribeacon.com/api/v1/usage", {
  method: "GET", headers, redirect: "manual",
  signal: AbortSignal.timeout(10000),
});
console.log(response.status);
await response.body?.cancel();

package main

import (
  "fmt"
  "net/http"
  "time"
  "encoding/json"
  "os"
  "path/filepath"
)

func main() {
  home, err := os.UserHomeDir(); if err != nil { panic("request failed; credentials and response omitted") }
  raw, err := os.ReadFile(filepath.Join(home, ".config/metribeacon/headers.json")); if err != nil { panic("request failed; credentials and response omitted") }
  var headers map[string]string
  if json.Unmarshal(raw, &headers) != nil { panic("invalid local headers") }
  request, err := http.NewRequest("GET", "https://metribeacon.com/api/v1/usage", nil)
  if err != nil { panic("request failed; credentials and response omitted") }
  for name, value := range headers { request.Header.Set(name, value) }
  client := &http.Client{Timeout: 10*time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
  response, err := client.Do(request)
  if err != nil { panic("request failed; credentials and response omitted") }
  defer response.Body.Close()
  fmt.Println(response.StatusCode)
}