Status

The Status OpenAPI tag exposes a single probe: get_backend_status (GET /status). The JSON body matches BackendStatus (environment, version) — see schemas in the API reference.

The published security requirement list for this path is empty (no bearer_auth); callers may still issue the request through SDK clients that attach your API key by default.

Operations vs wire routes

Concern	HTTP	operationId	Response
Backend info	GET /status	get_backend_status	BackendStatus

SDK coverage

Capability	Python	Rust (openapp_sdk)	Go	TypeScript (AsyncClient)
Get status	client.status.get()	client.status().get()	StatusAPI.GetBackendStatus	getBackendStatus

Typical errors

Transient 5xx responses and connection failures follow the same Errors & retries behavior as other reads. A 502 with a non-JSON body is surfaced as a transport-style failure on core-backed SDKs.

Examples

Get backend status

Python

status.get performs GET /status and returns a dict shaped like BackendStatus.

status = await client.status.get()
assert "version" in status

Go

GetBackendStatus returns typed BackendStatus.

import (
    "context"

    openapiclient "github.com/tomers/openapp-sdk/go"
)

resp, httpResp, err := client.StatusAPI.GetBackendStatus(context.Background()).Execute()
if err != nil {
    return err
}
defer httpResp.Body.Close()
_ = resp.GetEnvironment()
_ = resp.GetVersion()

Rust

Returns serde_json::Value for the BackendStatus payload.

use openapp_sdk::Client;

let client = Client::builder()
    .api_key("https://api.openapp.house/api/v1_openapp_YOUR_SECRET")
    .build()?;

let status = client.status().get().await?;
if let Some(v) = status["version"].as_str() {
    println!("{v}");
}

TypeScript

import { AsyncClient } from "@tomers/openapp-sdk";

const client = new AsyncClient("https://api.openapp.house/api/v1_openapp_YOUR_SECRET");
const status = await client.getBackendStatus();

Reachability / readiness gate

GET /status is a cheap, anonymous-allowed probe — useful as a startup gate before issuing real API calls in a long-running worker, or as a liveness check from infrastructure. Wrap it in a bounded retry loop and treat any 2xx as “the service is responding,” without inspecting the body. Pair this with Errors & retries for the broader retry policy on first-class operations.

Python

import asyncio

async def wait_for_backend(client, timeout_s: float = 30.0) -> dict:
    deadline = asyncio.get_event_loop().time() + timeout_s
    while True:
        try:
            return await client.status.get()
        except Exception:
            if asyncio.get_event_loop().time() >= deadline:
                raise
            await asyncio.sleep(1.0)

await wait_for_backend(client)

Go

import (
    "context"
    "errors"
    "time"
)

deadline := time.Now().Add(30 * time.Second)
for {
    _, httpResp, err := client.StatusAPI.GetBackendStatus(context.Background()).Execute()
    if err == nil {
        httpResp.Body.Close()
        break
    }
    if httpResp != nil {
        httpResp.Body.Close()
    }
    if time.Now().After(deadline) {
        return errors.New("backend not ready")
    }
    time.Sleep(time.Second)
}

Rust

use openapp_sdk::Client;
use std::time::{Duration, Instant};
use tokio::time::sleep;

let client = Client::builder()
    .api_key("https://api.openapp.house/api/v1_openapp_YOUR_SECRET")
    .build()?;

let deadline = Instant::now() + Duration::from_secs(30);
loop {
    match client.status().get().await {
        Ok(_) => break,
        Err(_) if Instant::now() < deadline => sleep(Duration::from_secs(1)).await,
        Err(err) => return Err(err.into()),
    }
}

TypeScript

async function waitForBackend(client: AsyncClient, timeoutMs = 30_000) {
  const deadline = Date.now() + timeoutMs;
  for (;;) {
    try {
      return await client.getBackendStatus();
    } catch (err) {
      if (Date.now() >= deadline) throw err;
      await new Promise((r) => setTimeout(r, 1_000));
    }
  }
}

Anonymous probe + version pin

Because security is empty for get_backend_status, you can call GET /status without an API key — useful when you want to verify the gateway is up before configuring credentials, or surface the running version in a deployment dashboard. The body shape is { "environment": string, "version": string } (Cargo package.version for the backend); compare it against the version you expect when pinning a particular release in CI.

Python

import httpx

async with httpx.AsyncClient(base_url="https://api.openapp.house") as http:
    resp = await http.get("/status")
    resp.raise_for_status()
    info = resp.json()

assert info["version"].startswith("0."), f"unexpected version: {info['version']}"

Go

import (
    "context"
    "fmt"

    openapiclient "github.com/tomers/openapp-sdk/go"
)

cfg := openapiclient.NewConfiguration()
cfg.Servers = openapiclient.ServerConfigurations{{URL: "https://api.openapp.house"}}
anon := openapiclient.NewAPIClient(cfg)

resp, httpResp, err := anon.StatusAPI.GetBackendStatus(context.Background()).Execute()
if err != nil {
    return err
}
defer httpResp.Body.Close()

if expected := "0.42.0"; resp.GetVersion() != expected {
    return fmt.Errorf("backend %q != expected %q", resp.GetVersion(), expected)
}

The configuration omits any Authorization header, matching the empty security list on /status.

Rust

use serde::Deserialize;

#[derive(Deserialize)]
struct BackendStatus { environment: String, version: String }

let info: BackendStatus = reqwest::Client::new()
    .get("https://api.openapp.house/api/v1/status")
    .send()
    .await?
    .error_for_status()?
    .json()
    .await?;

assert_eq!(info.environment, "production");

Skip the SDK client entirely when you do not yet have an API key and just want to know whether the gateway is reachable.

TypeScript

const info = await fetch("https://api.openapp.house/api/v1/status").then((r) => r.json());
if (!info.version) throw new Error("missing version");

In CI, fail the deploy job if info.version does not match the expected SHA or semver from the build pipeline.