Documentation

Check health

Check whether an SWQoS edge can currently reach upcoming leaders; readiness does not guarantee that a transaction will land.

// updated 2026-11-17

NOTE

Supanode issues keys through Telegram. Default minimum tip: 0.001 SOL; default rate: 15 sends/s per key per metro. Your key settings can differ. Declared tips are off by default and require enablement and a payment arrangement with Supanode. If your key returns partner_declared_tips, use an on-chain transfer instead.

GET https://fra.tpu.supanode.xyz/health

Authentication: No authentication.

Responses

200

Returns ok as plain text when an SWQoS edge can currently reach upcoming leaders; readiness does not guarantee that a transaction will land. A send can still be refused, for example with not_ready. No API key is required.

Content type: text/plain

ok

421

Unknown or removed TLS SNI or HTTP Host/:authority. Returns plain text without a JSON-RPC envelope or rejection object. The current hostname policy also applies to existing connections and resumed TLS sessions.

Content type: text/plain

This hostname is not served here. Check the endpoint address

503

Returns unhealthy as plain text when the edge is not ready, using the same readiness test as getHealth.

Content type: text/plain

unhealthy

Code samples

// src/bin/http_health.rs
// Builds on the example project (/reference/json-rpc#example-project).
use swqos_examples::swqos::Result;

#[tokio::main]
async fn main() -> Result<()> {
    let base = std::env::var("SWQOS_URL").unwrap_or_else(|_| "https://fra.tpu.supanode.xyz".into());
    let mut endpoint = reqwest::Url::parse(&base)?;
    endpoint.set_path("/health");
    endpoint.set_query(None);
    // This route does not require an API key.
    let response = reqwest::Client::new().get(endpoint).send().await?;
    let status = response.status();
    let body = response.text().await?;
    if !status.is_success() {
        return Err(format!("HTTP {status}: {body}").into());
    }
    println!("{body}");
    Ok(())
}
// http_health/main.go
package main

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

func run() error {
    base := os.Getenv("SWQOS_URL")
    if base == "" {
        base = "https://fra.tpu.supanode.xyz"
    }
    endpoint, err := url.Parse(base)
    if err != nil {
        return err
    }
    endpoint.Path = "/health"
    endpoint.RawQuery = ""
    // This route does not require an API key.
    response, err := http.Get(endpoint.String())
    if err != nil {
        return err
    }
    defer response.Body.Close()
    body, err := io.ReadAll(response.Body)
    if err != nil {
        return err
    }
    if response.StatusCode < 200 || response.StatusCode >= 300 {
        return fmt.Errorf("HTTP %d: %s", response.StatusCode, body)
    }
    fmt.Println(string(body))
    return nil
}

func main() {
    if err := run(); err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
}
// http-health.ts
export {}

const endpoint = new URL('/health', process.env.SWQOS_URL ?? 'https://fra.tpu.supanode.xyz')
// This route does not require an API key.
const response = await fetch(endpoint)
const body = await response.text()
if (!response.ok) throw new Error(`HTTP ${response.status}: ${body}`)
console.log(body)