Create sites — POST /v1/projects/sites

POST /v1/projects/sites

Generates a self-contained, mobile-responsive static site from a natural-language brief and deploys it live in one call.

One inference call turns brief (capped at 8 KiB) into a file manifest, which then runs through the SAME validation, guards and viewport guarantee as a hand-supplied manifest: index.html required at the root, absolute and traversal paths rejected, per-file and total size capped, and a mobile viewport meta tag injected into every HTML document that lacks one. The generated site is fully inline — no CDNs, no remote fonts or images — so it is CSP-safe. slug and name are optional: the model's own title is preferred, and a slug is derived or minted when none is given.

It writes into the SAME org-scoped store as /v1/project — it ensures a project (framework static) for the resolved slug and records a deployment — so this is a second entry point to one publish pipeline, not a second copy of project state. Publishing is free; what is billed is the model's tokens, to the caller's own ledger, and the storage the org holds past the free tier. The storage gate runs BEFORE any inference or upload, so an org past the tier that cannot pay a month of what it holds (402, or 503 when commerce is unreachable) generates and uploads NOTHING.

Answers 503 when object storage or inference is unconfigured, and 400 when the model's manifest cannot be parsed or fails the guards.

Scope: a validated principal is required (401 without one) and the site is published into THAT principal's org.

Request

4 fields, body application/json (required).

Response

200 body — 6 fields.

Failure carries the platform error shape — see Errors.

Examples

hanzo projects sites create

import { Configuration, ProjectApi } from 'hanzoai';

const api = new ProjectApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.postProjectsSites({ brief: "<brief>", model: "<model>" });

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).post_projects_sites(brief="<brief>", model="<model>")

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

resp, _, err := client.ProjectAPI.PostProjectsSites(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::post_projects_sites(&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).postProjectsSites();

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

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": "post_projects_sites",
           "input": {
             "brief": "<brief>",
             "model": "<model>"
           }
         }
       }
     }'

Project API · All Hanzo APIs · Interactive reference