# List health

URL: https://docs.hanzo.ai/docs/openapi/blueprint/get-blueprint-health

> Reports blueprint liveness and echoes the compute rate card in force.

`GET /v1/blueprint/health`

> [Blueprint →](https://docs.hanzo.ai/docs/openapi/blueprint) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides)

|               |                                            |
| ------------- | ------------------------------------------ |
| **Address**   | `https://api.hanzo.ai/v1/blueprint/health` |
| **Method**    | `GET`                                      |
| **Operation** | `get_blueprint_health`                     |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY`     |

Reports blueprint liveness and echoes the compute rate card in force.

The rate card is the one the estimator actually applies after the operator env
overlay, so an operator can confirm a tuned knob took effect rather than
inferring it from a price. Not JWT-gated — a liveness probe must be reachable —
and it always answers 200 while the subsystem is mounted.

## Request

`GET /v1/blueprint/health` takes no parameters and no body — the credential is the whole request.

## Response

| Status    | Body                      | Meaning |
| --------- | ------------------------- | ------- |
| `200`     | blueprint.blueprintHealth | ok      |
| `default` | problem-details           | refused |

`200` body — 7 fields.

| Field                          | In   | Type               | Always | Description                                                                                               |
| ------------------------------ | ---- | ------------------ | ------ | --------------------------------------------------------------------------------------------------------- |
| `blueprints`                   | body | integer (int64)    | —      | Blueprints is how many blueprints this build has embedded and priced.                                     |
| `rateCard`                     | body | blueprint.RateCard | —      |                                                                                                           |
| `rateCard.basis`               | body | string             | —      | Basis names where the rates come from, so a published price can be explained rather than merely asserted. |
| `rateCard.microUsdPerGbHour`   | body | integer (int64)    | —      | MicroUSDPerGBHour is the price of one GiB of memory for one hour, in millionths of a US dollar.           |
| `rateCard.microUsdPerVcpuHour` | body | integer (int64)    | —      | MicroUSDPerVCPUHour is the price of one vCPU for one hour, in millionths of a US dollar.                  |
| `service`                      | body | string             | —      | Service names the subsystem answering — always "blueprint".                                               |
| `status`                       | body | string             | —      | Status is "ok"; the route answers 200 whenever the subsystem is mounted.                                  |

Failure carries the platform error shape — see [Errors](https://docs.hanzo.ai/docs/errors).

## Examples

**CLI**

```bash
hanzo blueprint health
```

**SDK**

**.ts**

```ts
import { Configuration, BlueprintApi } from 'hanzoai';

const api = new BlueprintApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.getBlueprintHealth();
```

**.py**

```python
from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import BlueprintApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = BlueprintApi(client).get_blueprint_health()
```

**.go**

```go
cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.BlueprintAPI.GetBlueprintHealth(context.Background()).Execute()
if err != nil {
	return err
}
```

**.rs**

```rust
use hanzo_client::apis::{configuration::Configuration, blueprint_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = blueprint_api::get_blueprint_health(&cfg, Default::default()).await?;
```

**.java**

```java
import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.BlueprintApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new BlueprintApi(client).getBlueprintHealth();
```

**HTTP**

```bash
curl https://api.hanzo.ai/v1/blueprint/health \
  -H "Authorization: Bearer $HANZO_API_KEY"
```

**MCP**

Tool `blueprint`, op `get_blueprint_health` — POST the JSON-RPC envelope to `https://api.hanzo.ai/v1/mcp`.

```bash
curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "blueprint",
         "arguments": {
           "op": "get_blueprint_health",
           "input": {}
         }
       }
     }'
```

---

[Blueprint API](https://docs.hanzo.ai/docs/openapi/blueprint) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)