Get projects

Answers one project and every app in it.

GET /v1/platform/projects/{project}

Platform → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/platform/projects/{project}`
Method	`GET`
Operation	`get_platform_projects_by_project`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Answers one project and every app in it.

Each app carries its declaration — image, hosts, replicas, the KMS paths it reads (never a value) — together with the CD Application reconciling it, what its pods run, the newest release its registry publishes, and the drift between those four. 404 when no declaration in the caller's scope names the project.

Request

2 fields.

Field	In	Type	Required	Description
`project`	path	string	yes	Project is the project's name, from the path.
`org`	query	string	—	Org names the project's owner, defaulting to the caller's own scope — which for a SuperAdmin whose home is a brand org is the platform's.

Response

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

200 body — 77 fields.

Field	In	Type	Always	Description
`apps`	body	integer (int64)	—
`cdUnavailable`	body	platform.unreadable	—
`cdUnavailable.reason`	body	string	—	Reason is why: the cause for a SuperAdmin, and which plane for anyone else.
`clusterUnavailable`	body	platform.unreadable	—
`clusterUnavailable.reason`	body	string	—	Reason is why: the cause for a SuperAdmin, and which plane for anyone else.
`drift`	body	platform.driftTally	—
`drift.ok`	body	integer (int64)	—	OK is how many rows run what they declare.
`drift.red`	body	integer (int64)	—	Red is how many have drifted badly.
`drift.yellow`	body	integer (int64)	—	Yellow is how many have drifted within tolerance.
`health`	body	platform.healthTally	—
`health.degraded`	body	integer (int64)	—	Degraded is how many CD reports Degraded.
`health.healthy`	body	integer (int64)	—	Healthy is how many CD reports Healthy.
`health.missing`	body	integer (int64)	—	Missing is how many have no live objects at all.
`health.progressing`	body	integer (int64)	—	Progressing is how many are still rolling out.
`health.unknown`	body	integer (int64)	—	Unknown is every other verdict, and apps CD could not be asked about.
`members`	body	platform.ProjectApp[]	—	Members are the project's apps, sorted by namespace then name.
`members[].application`	body	string	—
`members[].automated`	body	boolean	—
`members[].cd`	body	platform.CDApp	—
`members[].cd.applied`	body	string	—	Applied is the universe commit CD last synced, from its deploy history.
`members[].cd.automated`	body	boolean	—	Automated is whether CD applies git without being asked.
`members[].cd.cluster`	body	string	—	Cluster is where the Application deploys: its destination cluster's name, else its server URL (https://kubernetes.default.svc is CD's own cluster).
`members[].cd.health`	body	string	—	Health is the workload's verdict: Healthy, Progressing, Degraded, Missing.
`members[].cd.message`	body	string	—	Message is why, when Health is not Healthy.
`members[].cd.name`	body	string	—	Name is the Application name the generator mints: <namespace>-<app>.
`members[].cd.namespace`	body	string	—	Namespace is the DESTINATION namespace as the CR declares it — where the workload lands.
`members[].cd.operationMessage`	body	string	—
`members[].cd.path`	body	string	—	Path is the values file CD renders against, relative to the chart source.
`members[].cd.phase`	body	string	—	Phase is the last sync operation's phase (Running, Succeeded, Failed) and OperationMessage is its message.
`members[].cd.project`	body	string	—	Project is the AppProject fence the sync is admitted under.
`members[].cd.reconciledAt`	body	string	—	ReconciledAt is when CD last compared this Application.
`members[].cd.revision`	body	string	—	Revision is the universe commit CD last compared the cluster against — what a sync applies.
`members[].cd.selfHeal`	body	boolean	—	SelfHeal is whether CD also corrects drift the cluster introduced.
`members[].cd.sync`	body	string	—	Sync is CD's verdict on git-versus-cluster: Synced, OutOfSync, or Unknown.
`members[].component`	body	string	—
`members[].digest`	body	string	—
`members[].drift`	body	platform.Verdict	—
`members[].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.
`members[].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.
`members[].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").
`members[].drift.flags[].severity`	body	string	—	Severity is this ONE finding's weight — yellow for stale and un-rolled, red for the other four.
`members[].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.
`members[].env`	body	platform.declareEnv[]	—
`members[].env[].name`	body	string	—
`members[].env[].public`	body	boolean	—	Public marks a value that may be WRITTEN INTO GIT.
`members[].env[].value`	body	string	—
`members[].hosts`	body	string[]	—
`members[].image`	body	string	—	Image is the image the declaration names: repository@digest when it pins a digest, else repository:tag.
`members[].latest`	body	string	—	Latest is the newest semver tag the registry publishes for its repository, "" when that cannot be read.
`members[].name`	body	string	—
`members[].org`	body	string	—
`members[].partOf`	body	string	—
`members[].path`	body	string	—
`members[].project`	body	string	—
`members[].replicas`	body	integer (int64)	—
`members[].repository`	body	string	—
`members[].running`	body	platform.Running	—
`members[].running.digest`	body	string	—	Digest is the digest the kubelet resolved that image to, "" when no pod has reported one yet.
`members[].running.image`	body	string	—	Image is the image the app's container runs, as the pod spec names it.
`members[].running.pods`	body	integer (int64)	—	Pods is how many pods carry the app's selector.
`members[].running.ready`	body	integer (int64)	—	Ready is how many of them report every container ready.
`members[].secrets`	body	platform.SecretRef[]	—
`members[].secrets[].env`	body	string	—	Env is the KMS environment slug.
`members[].secrets[].keys`	body	string[]	—	Keys are the names read from the path; empty means the whole path.
`members[].secrets[].path`	body	string	—	Path is the secret path, always absolute.
`members[].secrets[].project`	body	string	—	Project is the KMS project slug the path lives in.
`members[].tag`	body	string	—
`name`	body	string	—
`namespaces`	body	string[]	—
`org`	body	string	—
`sync`	body	platform.syncTally	—
`sync.outOfSync`	body	integer (int64)	—	OutOfSync is how many differ from git until someone syncs them.
`sync.synced`	body	integer (int64)	—	Synced is how many run what git declares.
`sync.unknown`	body	integer (int64)	—	Unknown is how many CD holds no verdict for, or could not be read.
`unreadable`	body	platform.unreadableFile[]	—	Unreadable are the values files in the owner's scope that do not parse, any of which may name this project.
`unreadable[].path`	body	string	—	Path is the values file, relative to the repository root.
`unreadable[].reason`	body	string	—	Reason is why it could not be read.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo platform projects get <project>

.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.getPlatformProjectsByProject({ project: 'project' });

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_projects_by_project(project='project')

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

resp, _, err := client.PlatformAPI.GetPlatformProjectsByProject(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_projects_by_project(&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).getPlatformProjectsByProject();

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

MCP reaches platform through the platform tool, which names its 38 operations with its own verbs — this one among them, under a name only MCP declares. describe explains any of them:

curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "describe",
         "arguments": {
           "op": "get_build"
         }
       }
     }'

Platform API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousList apps — GET /v1/platform/projects/{project}/apps NextList projects