Stops an app without deleting it.

Stops an app without deleting it. It scales the app's Service to zero replicas and marks it stopped, answering the updated application.

POST /v1/platform/projects/{project}/apps/{app}/stop

Platform → · All API references → · Six flows, four surfaces →


Address	`https://api.hanzo.ai/v1/platform/projects/{project}/apps/{app}/stop`
Method	`POST`
Operation	`post_platform_projects_by_project_apps_by_app_stop`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Stops an app without deleting it.

It scales the app's Service to zero replicas and marks it stopped, answering the updated application. Nothing else is removed — the record, its env, its domains and its deployment history all survive, and /start brings it back at the same replica count.

An app that is not deployed has no Service CR to scale and is 404. An unreachable cluster is 503 and a cluster that refuses the scale is 502. Because the pods stop, so does the compute metering. Requires a validated principal; 403 without one.

Request

2 fields.

Field	In	Type	Required	Description
`project`	path	string	yes	Project is the project the application lives under, from the path.
`app`	path	string	yes	App is the application's slug, from the path.

Response

Status	Body	Meaning
`200`	appView	ok

200 body — 34 fields.

Field	In	Type	Always	Description
`buildType`	body	string	—	BuildType is how a git app builds: `pack`, the zero-config default that detects the project, or `dockerfile`.
`createdAt`	body	integer	—	CreatedAt is when the app was created, unix seconds.
`currentDeploymentId`	body	string	—	CurrentDeploymentID is the deployment that is live — the pointer a deploy advances monotonically by version, so it never regresses to an older one.
`description`	body	string	—	Description is free text about what the app is.
`dockerfile`	body	string	—	Dockerfile is the path inside the repo to build from, for buildType `dockerfile`.
`domains`	body	string[]	—	Domains are the ingress hosts rendered into the app's CR, its own `<slug>.<org>.<sites host>` first.
`env`	body	EnvVarJSON[]	—	Env is the app's environment variables, with every SECRET value masked to "" — the plaintext is in KMS and this surface never echoes it.
`env[].key`	body	string	—	Key is the variable's name in the container, which must match `^[A-Za-z_][A-Za-z0-9_]*$`.
`env[].secret`	body	boolean	—	Secret says the value lives in KMS and never in the database.
`env[].value`	body	string	—	Value is the plaintext, and it is WRITE-ONLY once the entry is secret: a sealed value reads back as "", and sending "" again KEEPS what is sealed rather than…
`environment`	body	string	—	Environment is the deploy target this app names, `production` when none was given.
`health`	body	string	—	Health rolls ready-vs-desired replicas up to a colour: green (all ready), yellow (some ready, or deliberately scaled to zero), red (none), or "" when the…
`id`	body	string	—	ID is the server-minted application id (`app_…`).
`image`	body	imageView	—
`image.repository`	body	string	—	Repository is the image path without a tag (ghcr.io/acme/api). Required for source `image`, which runs it as-is.
`image.tag`	body	string	—	Tag is the tag to run: what the create declared, then RE-STAMPED on every transition to live with the tag that actually went live.
`name`	body	string	—	Name is the display name.
`namespace`	body	string	—	Namespace is where the app's cluster objects live, `tenant-<org>`.
`org`	body	string	—	Org is the tenant that owns the app.
`phase`	body	string	—	Phase is the operator's own `status.phase` for the app's Service CR, read from the cluster on this request.
`port`	body	integer	—	Port is the container port traffic is sent to.
`projectId`	body	string	—	ProjectID is the IAM project the app lives under, and it is that project's NAME — the (org,name) key IAM identifies it by, which is also what the `:project`…
`replicas`	body	integer	—	Replicas is how many copies the CR declares.
`repo`	body	gitSource	—
`repo.branch`	body	string	—	Branch is the branch a push-to-deploy build tracks, `main` when the create named none — a push to any other branch, and every tag push, builds nothing here.
`repo.provider`	body	string	—	Provider is derived from the URL — github, gitlab, bitbucket, or `git` for anything else.
`repo.url`	body	string	—	URL is the clone URL a git app builds from, stored as sent once the build path's allowlist accepted it (validateRepoURL).
`secretSync`	body	string	—	SecretSync is how far the app's secret env has got into the cluster: ""\|pending\|syncing\|ready\|failed (secrets.go).
`secretSyncDetail`	body	string	—	SecretSyncDetail is the honest reason when the sync is not ready — a missing CRD, an RBAC grant, a per-tenant credential.
`slug`	body	string	—	Slug is the app's identity in the cluster: the operator CR's name, the first label of its default host, and the `:app` path segment.
`source`	body	string	—	Source is what the app deploys FROM: `git`, which builds Repo, or `image`, which runs Image as it is.
`status`	body	string	—	Status is the lifecycle THIS store records: draft (created, nothing in the cluster yet), building, deploying, live, stopped or error.
`storageGb`	body	integer	—	StorageGB is the persistent volume size in GiB.
`updatedAt`	body	integer	—	UpdatedAt is when it last changed, unix seconds.

Failure carries the platform error shape — see Errors.

Examples

hanzo platform projects apps stop <project> <app>

import { Configuration, PlatformApi } from 'hanzoai';

const api = new PlatformApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.postPlatformProjectsByProjectAppsByAppStop({ project: 'project', 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).post_platform_projects_by_project_apps_by_app_stop(project='project', app='app')

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

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

use hanzo_cloud::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::post_platform_projects_by_project_apps_by_app_stop(&cfg, Default::default()).await?;

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

ApiClient client = new ApiClient();
client.setRequestInterceptor(b -> b.header("Authorization", "Bearer " + System.getenv("HANZO_API_KEY")));

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

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

The door reaches platform through the platform tool, which names its 39 operations with its own verbs — this one among them, under a name only the door 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": "list_builds"
         }
       }
     }'

Platform API · All Hanzo APIs · Interactive reference

Stops an app without deleting it.

Request

Response

Examples

On this page