# Check health

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

<Note>
Supanode issues keys through [Telegram](https://telegram.me/supanode_tgs). 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.
</Note>

`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`

```text title="Ready"
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`

```text title="UnknownHost"
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](https://supanode.xyz/docs/solana/sender/reference/json-rpc/health).

Content type: `text/plain`

```text title="Unhealthy"
unhealthy
```

## Code samples

```rust title="Rust"
// 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(())
}
```

```go title="Go"
// 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)
    }
}
```

```ts title="TypeScript"
// 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)
```
