# List edge — GET /v1/project/edge

URL: https://docs.hanzo.ai/docs/openapi/project/get-project-edge

> health reports whether a publish reaches readers, rather than whether it was accepted.

`GET /v1/project/edge`

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

|               |                                        |
| ------------- | -------------------------------------- |
| **Address**   | `https://api.hanzo.ai/v1/project/edge` |
| **Method**    | `GET`                                  |
| **Operation** | `get_project_edge`                     |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY` |

health reports whether a publish reaches readers, rather than whether it was
accepted. Those are different questions and only the second one was ever
visible.

It asks the edge and nothing else. There is no live call to the provider here:
Configured is a local fact, it is the fact that was missing, and a health check
that spends a third-party API call is one an operator learns not to run.

## Request

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

## Response

| Status    | Body              | Meaning             |
| --------- | ----------------- | ------------------- |
| `200`     | project.edgeState | ok                  |
| `503`     | project.edgeState | service unavailable |
| `default` | problem-details   | refused             |

`200` body — 8 fields.

| Field        | In   | Type      | Always | Description                                                                 |
| ------------ | ---- | --------- | ------ | --------------------------------------------------------------------------- |
| `configured` | body | boolean   | —      | Configured is whether the edge holds credentials to act at all.             |
| `error`      | body | string    | —      | Error is the blocker, so an operator reads it instead of guessing at it.    |
| `freshness`  | body | string    | —      | Freshness says, in one phrase, how long after a publish a reader sees it.   |
| `policy`     | body | object    | —      | Policy is the Cache-Control this edge serves each class of object with.     |
| `policy.*`   | body | string    | —      |                                                                             |
| `provider`   | body | string    | —      | Provider is the CDN behind this edge, or "none".                            |
| `reach`      | body | string\[] | —      | Reach is the apexes a publish is invalidated on.                            |
| `status`     | body | string    | —      | Status is "ok" when a publish reaches readers immediately, else "degraded". |

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

## Examples

**CLI**

```bash
hanzo project edge
```

**SDK**

**.ts**

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

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

**.py**

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

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

**.go**

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

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

**.rs**

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

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

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

**.java**

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

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

var result = new ProjectApi(client).getProjectEdge();
```

**HTTP**

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

**MCP**

Tool `project`, op `get_project_edge` — 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": "project",
         "arguments": {
           "op": "get_project_edge",
           "input": {}
         }
       }
     }'
```

---

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