# Get the tip floor

> Read an edge's observed landed-tip percentiles as a JSON array, without a JSON-RPC envelope.

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

Authentication: API key, one of: `x-api-key` header, `api-key` query, `Authorization: Bearer` header.

## Responses

### 200

Returns an array of zero or one observed tip-floor snapshots as an `application/json` array, without a JSON-RPC envelope. An empty array means no recent landing data is available.

Content type: `application/json`

Zero or one tip floor snapshot; an empty array means no recent landing data is available. The snapshot describes tips that already landed and does not predict landing; your key's [minimum tip](https://supanode.xyz/docs/solana/sender/tips#minimum-tip) still applies. Each metro reports its own values; use a named [metro hostname](https://supanode.xyz/docs/solana/sender/endpoints#regions) to compare them.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `[].time` | string (date-time) | yes | When the snapshot was computed, RFC 3339 in UTC, to the second. |
| `[].landed_tips_25th_percentile` | integer | yes | The edge's 25th landed-tip percentile, in lamports. minimum: `0`. |
| `[].landed_tips_50th_percentile` | integer | yes | The edge's 50th landed-tip percentile, in lamports. minimum: `0`. |
| `[].landed_tips_75th_percentile` | integer | yes | The edge's 75th landed-tip percentile, in lamports. minimum: `0`. |
| `[].landed_tips_95th_percentile` | integer | yes | The edge's 95th landed-tip percentile, in lamports. minimum: `0`. |
| `[].landed_tips_99th_percentile` | integer | yes | The edge's 99th landed-tip percentile, in lamports. minimum: `0`. |

```json title="NoRecentData"
[]
```

### 401

[`unauthorized`](https://supanode.xyz/docs/solana/sender/reference/errors#unauthorized): missing, unknown or revoked API key.

Content type: `application/json`

Reason-specific fields are included alongside these members, such as minimum, found, declared, available, unpaid_lamports, index, per_second and retry_after_ms. Failed preflight also includes Solana simulation fields such as err, logs and unitsConsumed.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `reason` | string | yes | Stable snake_case reason. Match on this; `message` wording can change, and the numeric codes are shared with Solana's RPC. |
| `message` | string | yes | What happened and what to change. Wording can change. |
| `retryable` | boolean | yes | Whether the unchanged request can succeed later. Wait before retrying, and check that the transaction has not expired. |
| `docs` | string (uri) | no | Optional error documentation URL followed by the reason anchor. Supanode endpoints omit this field. |

```json title="unauthorized"
{
  "reason": "unauthorized",
  "message": "API key missing or not recognized; pass it as the api-key query parameter, an x-api-key header or Authorization: Bearer",
  "retryable": false
}
```

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

## Code samples

```rust title="Rust"
// src/bin/http_tip_floor.rs
// Builds on the example project (/reference/json-rpc#example-project).
use serde::Deserialize;
use swqos_examples::swqos::{Result, required, url};

#[derive(Deserialize)]
struct TipFloor {
    time: String,
    landed_tips_50th_percentile: u64,
}

#[tokio::main]
async fn main() -> Result<()> {
    let mut endpoint = reqwest::Url::parse(&url())?;
    endpoint.set_path("/tip_floor");
    endpoint.set_query(None);
    let response = reqwest::Client::new().get(endpoint)
        .header("x-api-key", required("SWQOS_API_KEY")?)
        .send().await?;
    let status = response.status();
    let body = response.text().await?;
    if !status.is_success() {
        return Err(format!("HTTP {status}: {body}").into());
    }
    let floors: Vec<TipFloor> = serde_json::from_str(&body)?;
    if let Some(floor) = floors.first() {
        println!("{}: median landed tip {} lamports", floor.time, floor.landed_tips_50th_percentile);
    } else {
        println!("no recent landing data");
    }
    Ok(())
}
```

```go title="Go"
// http_tip_floor/main.go
package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"

    swqos "swqos-examples"
)

type TipFloor struct {
    Time string `json:"time"`
    Percentile50 uint64 `json:"landed_tips_50th_percentile"`
}

func run() error {
    apiKey, err := swqos.Required("SWQOS_API_KEY")
    if err != nil {
        return err
    }
    endpoint, err := url.Parse(swqos.URL())
    if err != nil {
        return err
    }
    endpoint.Path = "/tip_floor"
    endpoint.RawQuery = ""
    request, err := http.NewRequest(http.MethodGet, endpoint.String(), nil)
    if err != nil {
        return err
    }
    request.Header.Set("x-api-key", apiKey)
    response, err := http.DefaultClient.Do(request)
    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)
    }
    var floors []TipFloor
    if err := json.Unmarshal(body, &floors); err != nil {
        return err
    }
    if len(floors) == 0 {
        fmt.Println("no recent landing data")
    } else {
        fmt.Printf("%s: median landed tip %d lamports\n", floors[0].Time, floors[0].Percentile50)
    }
    return nil
}

func main() {
    if err := run(); err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
}
```

```ts title="TypeScript"
// http-tip-floor.ts
import { required, url } from './swqos.ts'

type TipFloor = { time: string; landed_tips_50th_percentile: number }

const endpoint = new URL('/tip_floor', url)
const response = await fetch(endpoint, { headers: { 'x-api-key': required('SWQOS_API_KEY') } })
const body = await response.text()
if (!response.ok) throw new Error(`HTTP ${response.status}: ${body}`)
const [floor] = JSON.parse(body) as TipFloor[]
if (floor) console.log(`${floor.time}: median landed tip ${floor.landed_tips_50th_percentile} lamports`)
else console.log('no recent landing data')
```
