Service status

Two small probes for operational use: one that tells you whether the service and its dependencies are healthy, and one that reports the deployed API version. Handy as a start-up check in your own service, or in a load balancer / uptime monitor.

Endpoints

Operation	Endpoint
Health check	GET /v1/meta/status
Deployed version	GET /v1/meta/version

These two are the only anonymous endpoints

status and version do not require an API key, so an autoscaler or uptime monitor can call them without a credential. The SDKs still send your key (they send it on every request) — that’s harmless. Every other endpoint in the API requires authentication.

Example

Python

import asyncio
from pagr import PagrApiClient, PagrError

async def main():
    async with PagrApiClient("pagr_prod_xxxxxxxx") as client:
        try:
            await client.get_status()                  # True, or raises
            print("API version:", await client.get_version())
        except PagrError as exc:
            print("Pagr is unavailable:", exc)

asyncio.run(main())

TypeScript

import { PagrApiClient, PagrError } from 'pagr';

const client = new PagrApiClient('pagr_prod_xxxxxxxx');

try {
  await client.getStatus();                            // true, or throws
  console.log('API version:', await client.getVersion());
} catch (err) {
  if (err instanceof PagrError) console.log('Pagr is unavailable:', err.message);
  else throw err;
}

Java

import org.example.PagrApiClient;
import org.example.exception.PagrException;

try (PagrApiClient client = new PagrApiClient("pagr_prod_xxxxxxxx")) {
    client.getStatus();                                // true, or throws
    System.out.println("API version: " + client.getVersion());
} catch (PagrException exc) {
    System.out.println("Pagr is unavailable: " + exc.getMessage());
}

C#

using Pagr.Sdk;
using Pagr.Sdk.Exceptions;

using var client = new PagrApiClient("pagr_prod_xxxxxxxx");

try
{
    await client.GetStatusAsync();                     // true, or throws
    Console.WriteLine($"API version: {await client.GetVersionAsync()}");
}
catch (PagrApiException exc)
{
    Console.WriteLine($"Pagr is unavailable: {exc.Message}");
}

Ruby

require "pagr"

client = Pagr::Client.new("pagr_prod_xxxxxxxx")

begin
  client.status                                        # true, or raises
  puts "API version: #{client.version}"
rescue Pagr::Error => e
  warn "Pagr is unavailable: #{e.message}"
end

C++

#include "pagr/PagrApiClient.hpp"
#include "pagr/exceptions.hpp"

pagr::PagrApiClient client("pagr_prod_xxxxxxxx");

try {
    client.get_status();                               // true, or throws
    if (const auto version = client.get_version()) {
        std::cout << "API version: " << *version << "\n";
    }
} catch (const pagr::PagrApiException& exc) {
    std::cout << "Pagr is unavailable: " << exc.what() << "\n";
}

get_status_async / get_version_async forms are also available.

cURL

# Health — 200 means healthy, 503 means a dependency is down
curl -i "https://api.pagr.eu/v1/meta/status"

# Version
curl "https://api.pagr.eu/v1/meta/version"
# → { "version": "1.4.2.0" }

No Authorization header needed for either.

Health check

GET /v1/meta/status

A readiness probe: it verifies the API’s two hard dependencies — the database and blob storage — are reachable, not merely that the process is running.

Path parameters

None.

Query parameters

None.

Response

Status	Body	Meaning
200 OK	(empty)	Both dependencies responded. The service is ready to take traffic.
503 Service Unavailable	A plain-text reason	A dependency is unreachable.

The 503 body is plain text, not the error envelope

Unlike every other endpoint, a failing health check returns a bare string (for example the databases are not available) rather than the { "error": { "code", "message" } } shape. Don’t try to JSON-parse it. The SDKs handle this for you: get_status() returns true on 200 and raises a PagrError subclass otherwise, so you never see the body.

Deployed version

GET /v1/meta/version

Reports the version of the deployed public-API assembly. Useful for correlating behaviour with a specific deployment in a bug report.

Path parameters

None.

Query parameters

None.

Response

200:

{ "version": "1.4.2.0" }

Field	Type	Description
version	string	The deployed assembly version, or "unknown" when it can’t be determined.

The SDKs return the string directly (or null/None/std::nullopt if the field is absent), not the wrapper object.

Not the API contract version

This is a build version, not the API version. The API version is the /v1 path segment and changes only on a breaking contract change — see How the API works → Base URL and versioning.

SDK reference

Operation	Python	TypeScript	Java	C#	Ruby	C++
Health check	get_status()	getStatus()	getStatus()	GetStatusAsync()	status	get_status()
Deployed version	get_version()	getVersion()	getVersion()	GetVersionAsync()	version	get_version()

get_status returns true when healthy and raises otherwise — it never returns false. Wrap it in a try rather than testing the return value.

Errors

Status	When
503	A dependency (database or blob storage) is unreachable. Surfaces as a PagrError subclass in the SDKs.

As reads, both endpoints are retried by the SDKs on transient failures — including 503 — so a single blip won’t fail your start-up check. See Handle errors and retries.

Related articles

• Handle errors and retries — the exception tree and the retry policy.
• How the API works — base URL and versioning.