Opens a deployment and hands back a short-lived, prefix-scoped grant to write…

POST /v1/projects/{slug}/deployments

Opens a deployment and hands back a short-lived, prefix-scoped grant to write its bytes straight to object storage. Answers 202.

This is the path for a site too large to send as one archive: a real export is hundreds of megabytes against a 16 MiB body limit, so the bytes deliberately do NOT pass through the API. The answer carries bucket, prefix and upload — a presigned POST policy that S3 itself confines to this site's prefix (starts-with <org>/<slug>/), expires in 30 minutes and bounds each object. So a build writes its own files and holds no standing bucket credential; there is nothing to rotate and nothing that leaks between tenants. Never guess the prefix — it is server-derived, and a guessed one lands where nothing is served.

The deployment is queued until POST .../deployments/{id}/complete flips it live (or error). That completion is also where DELETION happens: the grant authorizes writes only, so a build cannot remove a file, and cloud reconciles the prefix against the keys manifest the completion carries. A build that dies before completing leaves the deployment queued rather than a half-live site.

The grant is on the 202 and NOWHERE else — it is never stored and never replayed on a later read, so it cannot outlive the build it was minted for. A deployment whose grant could not be minted is still created and still completable; it simply carries no upload, and a caller with no other way to write should treat that as the failure it is.

Billing: the hosting gate runs BEFORE anything is created (402 unfunded, 503 commerce unreachable), and the debit lands on the completion that goes live — never on a queued or failed build.

Scope: a validated principal is required (403 without one) and the site is resolved within that principal's org, so another tenant's slug is a 404.

Request

3 fields, body application/json (required).

Response

202 body — 21 fields.

Failure carries the platform error shape — see Errors.

Examples

hanzo projects deployments create <slug>

import { Configuration, ProjectsApi } from 'hanzoai';

const api = new ProjectsApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.postProjectsBySlugDeployments({ slug: 'slug', commit: "<commit>", slug: "<slug>" });

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

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = ProjectsApi(client).post_projects_by_slug_deployments(slug='slug', commit="<commit>", slug="<slug>")

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

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

use hanzo_cloud::apis::{configuration::Configuration, projects_api};

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

let result = projects_api::post_projects_by_slug_deployments(&cfg, Default::default()).await?;

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

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

var result = new ProjectsApi(client).postProjectsBySlugDeployments();

curl -X POST https://api.hanzo.ai/v1/projects/<slug>/deployments \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "commit": "<commit>",
       "slug": "<slug>"
     }'

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_projects"
         }
       }
     }'

Projects API · All Hanzo APIs · Interactive reference