List edge — GET /v1/project/edge

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

GET /v1/project/edge

Project → · All API references → · Get started →

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.

Examples

CLI

SDK

HTTP

MCP

hanzo project edge

.ts

.py

.go

.rs

.java

import { Configuration, ProjectApi } from 'hanzoai';

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

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()

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
}

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?;

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();

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

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

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 · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousGet project NextGet sites — GET /v1/project/sites/{slug}