Get fleet

Returns one platform service, resolved to production by default.

GET /v1/platform/fleet/{app}

Platform → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/platform/fleet/{app}`
Method	`GET`
Operation	`get_platform_fleet_by_app`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Returns one platform service, resolved to production by default.

It returns a single platform service by its CR name, with the same declared-versus-running and drift facts the board carries. The name must be a DNS-1123 label; anything else is 400.

Namespaces are scanned in lifecycle order — main, then test, then dev — and the first match wins, so a bare name resolves to PRODUCTION. The scan covers only the namespaces the caller is authorized for, so an org admin can never read a service outside their own org, and a name found in none of them is 404 rather than a leak.

Request

2 fields.

Field	In	Type	Required	Description
`app`	path	string	yes	App is the service's CR name, from the path.
`env`	query	string	—	Env narrows the scan to one lifecycle env: main, test or dev.

Response

Status	Body	Meaning
`200`	platform.AppView	ok
`default`	problem-details	refused

200 body — 21 fields.

Field	In	Type	Always	Description
`app`	body	string	—	service / CR name, e.g. iam
`cluster`	body	string	—	always "hanzo-k8s"; cross-cluster federation is a follow-up phase
`declaredTag`	body	string	—	spec.image.tag — the tag the CR SAYS to run; anything but vX.Y.Z is red drift
`drift`	body	platform.Verdict	—
`drift.flags`	body	platform.DriftFlag[]	—	Flags are the findings behind the severity, in detection order: floating-declared, floating-running, stale, un-rolled, then the release-artifact ones.
`drift.flags[].kind`	body	string	—	Kind is which finding this is, one of stale, un-rolled, floating-declared, floating-running, no-release or zero-assets.
`drift.flags[].message`	body	string	—	Message is the finding in words, naming the tags that produced it ("running v1.2.3 has not rolled to declared v1.2.4").
`drift.flags[].severity`	body	string	—	Severity is this ONE finding's weight — yellow for stale and un-rolled, red for the other four.
`drift.severity`	body	string	—	Severity is the roll-up over Flags — red if any flag is red, else yellow if any is yellow, else ok.
`endpoints`	body	string[]	—	status.endpoints the operator published for this service; empty until it reconciles
`env`	body	string	—	main\|test\|dev
`health`	body	string	—	green\|yellow\|red\|"" (unknown)
`id`	body	string	—	<org>/<app>/<env>, e.g. hanzoai/iam/main
`latestTag`	body	string	—	newest released tag; "" until the GH release reader lands, so "stale" cannot fire yet
`namespace`	body	string	—	namespace the row was scanned from: a platform one (hanzo, hanzo-testnet, …) or a tenant-<org>
`org`	body	string	—	image namespace, e.g. hanzoai
`phase`	body	string	—	operator status.phase (Running/…)
`registry`	body	string	—	spec.image.repository verbatim (ghcr.io/hanzoai/iam); Org and Repo are read off it
`repo`	body	string	—	owner/repo, e.g. hanzoai/iam
`role`	body	string	—	operator spec.role (sql\|kv\|generic\|ingress\|…) or "" — the one declared class field
`runningTag`	body	string	—	the tag the live Deployment actually runs; "" when unreadable — unknown, not a guess

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo platform fleet get <app>

.ts

.py

.go

.rs

.java

import { Configuration, PlatformApi } from 'hanzoai';

const api = new PlatformApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.getPlatformFleetByApp({ app: 'app' });

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import PlatformApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = PlatformApi(client).get_platform_fleet_by_app(app='app')

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

resp, _, err := client.PlatformAPI.GetPlatformFleetByApp(context.Background()).Execute()
if err != nil {
	return err
}

use hanzo_client::apis::{configuration::Configuration, platform_api};

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

let result = platform_api::get_platform_fleet_by_app(&cfg, Default::default()).await?;

import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.PlatformApi;

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

var result = new PlatformApi(client).getPlatformFleetByApp();

curl https://api.hanzo.ai/v1/platform/fleet/<app> \
  -H "Authorization: Bearer $HANZO_API_KEY"

Tool platform, op get_platform_fleet_by_app — 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": "platform",
         "arguments": {
           "op": "get_platform_fleet_by_app",
           "input": {
             "app": "<app>"
           }
         }
       }
     }'

Platform API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousList environments NextList fleet