Cirrus Host documentation

Ship Workers to the edge in seconds. The helix CLI bundles your code locally with esbuild and uploads it to Cirrus Host; this guide walks through the CLI, the REST API (80+ endpoints with granular API key scopes), and worker configuration.

Quickstart

Ship your first worker in four commands.

npm i -g @cirrustech/helix
helix login

helix login opens a device-code flow against Cirrus Host and stores credentials in ~/.config/helix/config.json.

helix init my-project/hello
cd my-project/hello

This creates a helix.json, a src/worker.ts entry, and a tsconfig.json.

helix deploy

Your worker is bundled with esbuild and uploaded. The first deploy provisions a hostname like hello.my-project.helx.dev with SSL automatically.

helix logs --tail

Each request to your worker streams in real time, including console.log output and uncaught exceptions.

Concepts

Cirrus Host runs your code on a globally-distributed V8 isolate runtime — your Worker boots in under a millisecond in 300+ cities. Key resources:

• Organizations — top-level accounts. Every user gets a personal org; team orgs have role-based members (owner, admin, billing, developer, viewer).
• Projects — logical groupings of related deployments within an org. A project has a slug (e.g. my-project) used in URLs and a billing account for charges.
• Deployments — individual workers or containers. Each deployment has a name (e.g. hello) and runs at <deployment>.<project>.helx.dev by default. Custom domains attach via CNAME.
• Versions — every helix deploy creates a new version. The latest is live; older versions can be rolled back to via the panel or API.
• Resources — project-scoped databases (D1/SQLite), object storage buckets (R2), and key-value stores. Attached to deployments via bindings.
• Billing accounts — org-level containers for plans, payment methods, and usage tracking. Projects are assigned to a billing account. Billing accounts can be shared across orgs.

Helix CLI commands

helix deploy

Bundles main from helix.json with esbuild (modules + tree-shaking, target ES2022, with nodejs_compat), then uploads as a multipart form with the metadata declared in your config. Re-deploying the same (project, name) bumps the version and replaces the previous bundle in place.

helix logs

By default helix logs shows the last 50 lines retained on the platform. --tail opens a WebSocket and streams in real time. Logs are produced by every invocation event sent to the platform tail consumer; no observability config is required on your side.

env & secrets

Plain env vars are visible in the dashboard and applied as plain_text bindings on the next deploy. Secrets are AES-GCM encrypted at rest and applied as secret_text bindings — their values are never logged or returned by the API.

Custom domains

Run helix domain add example.com, then point a CNAME for example.com at cname.cirrus-host.com. SSL is provisioned automatically in under 60 seconds. Once active, the deployment is reachable at the custom hostname in addition to its default URL.

Resources

Workers don't get any storage by default. To use a database, bucket, or key-value store, you provision it once with the CLI, then declare it as a binding in helix.json. Resources live at the project level and can be attached to any deployment in that project.

helix.json

The single config file at the root of every project. Only name, project, and main are required.

{
  "name": "hello",
  "project": "my-project",
  "main": "src/worker.ts",
  "compatibility_date": "2025-04-01",
  "compatibility_flags": ["nodejs_compat"],
  "vars": { "STAGE": "prod" },
  "bindings": [
    { "type": "kv",     "name": "MY_CACHE",   "resource": "cache" },
    { "type": "bucket", "name": "IMAGES",     "resource": "images" },
    { "type": "db",     "name": "PRIMARY_DB", "resource": "primary" }
  ],
  "assets": { "directory": "./public" },
  "routes": ["api.example.com/*"]
}

Bindings

Bindings in helix.json attach a project resource onto this deployment under a chosen variable name. With helix deploy the resource must already exist (see Resources); the one-click deploy button can create it on the fly. Either way, the binding declares it visible at env.<NAME> for this deployment.

Example flow:

helix db create primary
# adds an entry to your project's resources

# in helix.json:
"bindings": [
  { "type": "db", "name": "DB", "resource": "primary" }
]

# in your worker:
await env.DB.exec('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, email TEXT)');
await env.DB.prepare('INSERT INTO users (email) VALUES (?)').bind('a@b.com').run();
const { results } = await env.DB.prepare('SELECT * FROM users').all();

Static assets

Add "assets": { "directory": "./public" } to helix.json. The CLI bundles every file under ./public and serves them from env.ASSETS at runtime.

One-click deploy button

Add a "Deploy to Cirrus Host" button to your project's README so visitors can fork-and-deploy in a single click.

{
  "name": "url-shortener",
  "kind": "worker",
  "main": "src/worker.ts",
  "bindings": [
    { "type": "db", "name": "DB", "resource": "links" }
  ],
  "template": {
    "name": "URL Shortener",
    "description": "Tiny URL shortener with admin UI.",
    "bundle": "dist/worker.js",
    "env": [
      { "name": "ADMIN_PASSWORD", "description": "Password for /admin", "required": true, "generator": "secret" },
      { "name": "DEFAULT_REDIRECT", "description": "Where unknown short links go", "default": "https://example.com" }
    ]
  }
}

https://cirrus-host.com/deploy?url=https://github.com/<owner>/<repo>

Add a button to your README:

[![Deploy to Cirrus Host](https://cirrus-host.com/badge.svg)](https://cirrus-host.com/deploy?url=https://github.com/owner/repo)

Authentication

Every endpoint used by the panel is also available over the REST API. Authenticate with an API key created from the dashboard or via the API keys endpoint:

Authorization: Bearer helx_...

Base URL: https://cirrus-host.com/api/v1

All requests and responses use JSON (Content-Type: application/json) unless noted otherwise. Deployment uploads use multipart/form-data.

Session cookie authentication (from the browser) also works and grants full access.

API key scopes

API keys support granular scopes that control which resources and actions the key may access. Each scope follows the pattern resource:action. The wildcard scope * grants unrestricted access (backwards-compatible with older keys).

When creating an API key, specify the scopes array. If omitted, the key receives ["*"]. Invalid scope names are rejected with a 400 error.

If a request requires a scope the API key does not carry, the API returns:

{ "error": "insufficient scope: requires 'deployments:write'", "required_scope": "deployments:write" }

Available scopes

Project restrictions

API keys can optionally be restricted to specific projects by passing allowed_projects (an array of project slugs) when creating the key. This is orthogonal to scopes — a key can have full scopes but only be able to act on certain projects.

If a request targets a project the key is not authorized for, the API returns:

{ "error": "api key not authorized for project 'my-project'" }

Keys with allowed_projects: null (the default) may access all projects the user has membership in.

Account

{
  "user": { "id": "...", "email": "...", "name": "...", "username": "...", "avatar": "...", "balance_cents": 0 },
  "unread_notifications": 3,
  "pending_invites": 1
}

{
  "projects": 5, "deployments": 12,
  "requests24h": 48201, "errors24h": 7,
  "activity": [ ... ],
  "timeseries": [ { "t": "2026-05-07T00:00:00Z", "requests": 1200, "errors": 2 } ]
}

Projects

{ "name": "New Name" }

{ "billing_account_id": "ba_..." }

Deployments

{
  "project": { ... },
  "deployment": {
    "id": "...", "name": "hello", "status": "active",
    "version": 3, "url": "hello.my-project.helx.dev",
    "versions": [ { "version": 3, "message": "fix routing" }, ... ],
    "env_vars": [ { "name": "STAGE", "value": "prod" } ],
    "secrets": [ { "id": "...", "name": "API_KEY", "hint": "sk_l..." } ],
    "hostnames": [ { "hostname": "api.example.com", "ssl_status": "active" } ],
    "bindings": [ { "type": "db", "name": "DB", "resource_name": "primary" } ]
  },
  "membership": { "role": "owner", "permissions": [] }
}

{ "deployment_id": "...", "version": 4, "url": "hello.my-project.example.com" }

{ "ok": true, "version": 2 }

Containers

Container deployments run OCI images instead of Worker scripts. The same project and billing model applies.

{
  "deployment_id": "...", "kind": "container",
  "url": "myapp.project.helx.dev",
  "machines": [ { "id": "...", "state": "running", "region": "ord" } ]
}

{ "replicas": 3 }

Cron jobs

Attach recurring scheduled triggers to any worker deployment. The platform evaluates cron expressions every minute (UTC) and dispatches a POST request to your worker's fetch handler with the header X-Cron-Trigger: <job-name>.

export default {
  async fetch(request) {
    const cron = request.headers.get('X-Cron-Trigger');
    if (cron) {
      // Handle scheduled job by name
      if (cron === 'cleanup') await doCleanup();
      return new Response('ok');
    }
    // Normal request handling
    return new Response('Hello!');
  }
}

[{
  "id": "...", "name": "cleanup", "schedule": "0 3 * * *",
  "description": "Nightly data cleanup", "enabled": 1,
  "last_run_at": "2025-05-07T03:00:00.000Z", "last_status": "success"
}]

{ "name": "cleanup", "schedule": "0 3 * * *", "description": "Nightly data cleanup" }

{ "schedule": "0 6 * * *", "enabled": false }

[{
  "id": "...", "status": "success", "duration_ms": 42,
  "detail": null, "started_at": "2025-05-07T03:00:00.000Z"
}]

Environment variables

{ "name": "STAGE", "value": "prod" }

Secrets

{ "name": "STRIPE_KEY", "value": "sk_live_..." }

Custom domains

{ "hostname": "api.example.com" }

Resources

[
  { "id": "...", "type": "database", "name": "primary", "cf_resource_id": "...",
    "created_at": "2026-05-01T...", "binding_count": 2 },
  { "id": "...", "type": "bucket", "name": "uploads", "binding_count": 1 }
]

Resource explorer

Query databases, browse buckets, and manage KV stores directly from the API.

Database

{ "sql": "SELECT * FROM users WHERE id = ?", "params": [42] }

Bucket (Object Storage)

{ "key": "path/to/file.png" }

KV Store

{ "key": "session:abc", "value": "{...}", "expiration_ttl": 3600 }

{ "key": "session:abc" }

Bindings

{ "resource_id": "res_...", "name": "MY_DB" }

Metrics

Live logs

{ "t": "2026-05-07T01:03:32.896Z", "level": "info", "msg": "GET /api/users → ok (2.4ms cpu)" }

Usage

{
  "plan": { "name": "Pro", "included_requests": 10000000, ... },
  "period_requests": 1284502, "period_cpu_ms": 483920,
  "included_requests": 10000000, "included_cpu_ms": 5000000,
  "daily": [ { "date": "2026-05-01", "requests": 41203, "errors": 12, "cpu_ms": 14820 } ],
  "invoices": [ ... ]
}

Members & invites

Project members

{ "role": "admin", "permissions": ["deployments:write", "env:read"] }

{ "user_id": "..." }

Personal invites

Organizations

Endpoints are at /api/v1/orgs.

{ "name": "My Team", "slug": "my-team", "description": "..." }

{ "name": "New Name", "description": "..." }

Org members

{ "role": "admin" }

Org invites

{ "token": "..." }

{ "token": "..." }

Org logo

Billing accounts

Endpoints are at /api/v1/billing-accounts. Billing accounts belong to orgs and aggregate usage + charges for all projects assigned to them.

{ "org_slug": "my-team", "name": "Production", "description": "..." }

{ "name": "...", "hard_limit_cents": 10000, "soft_limit_cents": 5000 }

{ "plan_id": "..." }

Billing account sharing

{ "org_slug": "partner-team", "permission": "use" }

Payment methods

User-level (legacy)

{ "payment_method_id": "pm_..." }

Billing-account-level

{ "payment_method_id": "pm_...", "make_default": true }

API keys

[{
  "id": "...", "name": "CI Deploy Key", "key_prefix": "helx_abc",
  "scopes": ["deployments:write", "projects:read"],
  "allowed_projects": ["my-api"],
  "expires_at": "2026-08-01T00:00:00Z", "created_at": "..."
}]

{
  "name": "CI Deploy Key",
  "scopes": ["deployments:write", "projects:read"],
  "allowed_projects": ["my-api", "my-frontend"],
  "expires_in_days": 90
}

{
  "id": "...", "secret": "helx_abc123...", "prefix": "helx_abc",
  "name": "CI Deploy Key",
  "scopes": ["deployments:write", "projects:read"],
  "allowed_projects": ["my-api", "my-frontend"],
  "expires_at": "2026-08-05T..."
}

{
  "scopes": ["account:read", "account:write", ...],
  "groups": { "account": { "label": "Account", "scopes": [...] }, ... },
  "descriptions": { "account:read": "View your profile, email, and avatar", ... }
}

Sessions

[
  { "id": "...", "kind": "web", "label": "Browser", "ip": "...", "current": true, "expires_at": "..." },
  { "id": "...", "kind": "cli", "label": "Helix CLI", "last_used_at": "..." }
]

Notifications

Plans

Admin

Admin endpoints require the super_admin or reseller_admin role plus the admin:read or admin:write scope. All endpoints are at /api/v1/admin.

{ "plan_id": "..." }

Error codes

The API returns standard HTTP codes with a JSON body of the form { "error": "..." }.

When a scope is missing, the response also includes a required_scope field:

{ "error": "insufficient scope: requires 'deployments:write'", "required_scope": "deployments:write" }

Rate limits

The API does not impose hard rate limits today, but abusive patterns (more than ~100 requests/second per key) may be throttled. Deploy endpoints perform real work against the edge runtime and should not be called in tight loops.

Code examples

curl https://cirrus-host.com/api/v1/projects \
  -H "Authorization: Bearer $HELIX_TOKEN"

curl -X POST https://cirrus-host.com/api/v1/projects \
  -H "Authorization: Bearer $HELIX_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"slug":"my-api","name":"My API","description":"Backend services"}'

# Build first
esbuild src/worker.ts --bundle --format=esm --outfile=dist/worker.js

# Upload
curl -X POST https://cirrus-host.com/api/v1/projects/my-api/deployments \
  -H "Authorization: Bearer $HELIX_TOKEN" \
  -F "bundle=@dist/worker.js" \
  -F 'metadata={"name":"api","message":"v1.2.0","compatibility_date":"2025-04-01"}'

curl -X POST https://cirrus-host.com/api/v1/deployments/$DEP_ID/env \
  -H "Authorization: Bearer $HELIX_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"DATABASE_URL","value":"postgres://..."}'

curl -X POST https://cirrus-host.com/api/v1/api-keys \
  -H "Authorization: Bearer $HELIX_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "CI Deploy",
    "scopes": ["deployments:write", "projects:read"],
    "allowed_projects": ["my-api"],
    "expires_in_days": 90
  }'

# Create the database
curl -X POST https://cirrus-host.com/api/v1/projects/my-api/resources \
  -H "Authorization: Bearer $HELIX_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"type":"database","name":"primary"}'

# Bind it to a deployment
curl -X POST https://cirrus-host.com/api/v1/deployments/$DEP_ID/bindings \
  -H "Authorization: Bearer $HELIX_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"resource_id":"RESOURCE_ID","name":"DB"}'

curl -X POST https://cirrus-host.com/api/v1/resources/$RES_ID/database/query \
  -H "Authorization: Bearer $HELIX_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sql":"SELECT * FROM users WHERE email = ?","params":["alice@example.com"]}'

curl "https://cirrus-host.com/api/v1/deployments/$DEP_ID/metrics?since=7d" \
  -H "Authorization: Bearer $HELIX_TOKEN"

websocat "https://cirrus-host.com/api/v1/deployments/$DEP_ID/tail" \
  -H "Authorization: Bearer $HELIX_TOKEN"

curl -X POST https://cirrus-host.com/api/v1/deployments/$DEP_ID/domains \
  -H "Authorization: Bearer $HELIX_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"hostname":"api.example.com"}'

const API = "https://cirrus-host.com/api/v1";
const TOKEN = process.env.HELIX_TOKEN;

async function api(path, opts = {}) {
  const res = await fetch(API + path, {
    ...opts,
    headers: {
      Authorization: `Bearer ${TOKEN}`,
      "Content-Type": "application/json",
      ...opts.headers,
    },
    body: opts.body ? JSON.stringify(opts.body) : undefined,
  });
  if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
  return res.json();
}

const projects = await api("/projects");
console.log(projects);

// Create project
const project = await api("/projects", {
  method: "POST",
  body: { slug: "my-api", name: "My API" },
});

// Deploy (multipart)
const form = new FormData();
form.append("bundle", new Blob([bundleCode], { type: "application/javascript" }));
form.append("metadata", JSON.stringify({
  name: "api",
  message: "initial deploy",
  compatibility_date: "2025-04-01",
}));

const deploy = await fetch(`${API}/projects/my-api/deployments`, {
  method: "POST",
  headers: { Authorization: `Bearer ${TOKEN}` },
  body: form,
}).then(r => r.json());

console.log("Live at:", deploy.url);

// Create a database
const db = await api("/projects/my-api/resources", {
  method: "POST",
  body: { type: "database", name: "primary" },
});

// Create a KV store
const kv = await api("/projects/my-api/resources", {
  method: "POST",
  body: { type: "kv", name: "cache" },
});

// Bind both to a deployment
await api(`/deployments/${deployId}/bindings`, {
  method: "POST",
  body: { resource_id: db.id, name: "DB" },
});
await api(`/deployments/${deployId}/bindings`, {
  method: "POST",
  body: { resource_id: kv.id, name: "CACHE" },
});

const key = await api("/api-keys", {
  method: "POST",
  body: {
    name: "CI Deploy",
    scopes: ["deployments:write", "projects:read", "env:write"],
    allowed_projects: ["my-api"],
    expires_in_days: 90,
  },
});
console.log("Secret (store this!):", key.secret);

const metrics = await api(`/deployments/${depId}/metrics?since=24h`);
console.log("Requests:", metrics.total_requests);
console.log("p99 CPU:", metrics.p99_cpu_ms, "ms");

import os, requests

API = "https://cirrus-host.com/api/v1"
TOKEN = os.environ["HELIX_TOKEN"]
HEADERS = {"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"}

def api(method, path, **kwargs):
    r = requests.request(method, API + path, headers=HEADERS, **kwargs)
    r.raise_for_status()
    return r.json()

projects = api("GET", "/projects")
for p in projects:
    print(f"{p['slug']} — {p['name']} ({p['deployment_count']} deployments)")

# Create project
project = api("POST", "/projects", json={"slug": "my-api", "name": "My API"})

# Deploy
with open("dist/worker.js", "rb") as f:
    r = requests.post(
        f"{API}/projects/my-api/deployments",
        headers={"Authorization": f"Bearer {TOKEN}"},
        files={"bundle": ("worker.js", f)},
        data={"metadata": '{"name":"api","message":"v1.0"}'},
    )
    deploy = r.json()
    print("Live at:", deploy["url"])

# Create database
db = api("POST", "/projects/my-api/resources", json={"type": "database", "name": "primary"})

# Bind to deployment
api("POST", f"/deployments/{dep_id}/bindings", json={"resource_id": db["id"], "name": "DB"})

# Query it
result = api("POST", f"/resources/{db['id']}/database/query",
             json={"sql": "SELECT COUNT(*) as n FROM users"})
print("Users:", result["result"])

key = api("POST", "/api-keys", json={
    "name": "CI Deploy",
    "scopes": ["deployments:write", "projects:read"],
    "allowed_projects": ["my-api"],
    "expires_in_days": 90,
})
print("Secret:", key["secret"])

usage = api("GET", "/usage")
print(f"Requests: {usage['period_requests']:,} / {usage['included_requests']:,}")
print(f"CPU: {usage['period_cpu_ms']:,}ms / {usage['included_cpu_ms']:,}ms")
for day in usage["daily"][-7:]:
    print(f"  {day['date']}: {day['requests']:,} req, {day['errors']} err")

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

var (
    apiBase = "https://cirrus-host.com/api/v1"
    token   = os.Getenv("HELIX_TOKEN")
)

func api(method, path string, body any) (map[string]any, error) {
    var r io.Reader
    if body != nil {
        b, _ := json.Marshal(body)
        r = bytes.NewReader(b)
    }
    req, _ := http.NewRequest(method, apiBase+path, r)
    req.Header.Set("Authorization", "Bearer "+token)
    req.Header.Set("Content-Type", "application/json")
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    var result map[string]any
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

projects, _ := api("GET", "/projects", nil)
fmt.Println(projects)

key, _ := api("POST", "/api-keys", map[string]any{
    "name":             "CI Deploy",
    "scopes":           []string{"deployments:write", "projects:read"},
    "allowed_projects": []string{"my-api"},
    "expires_in_days":  90,
})
fmt.Println("Secret:", key["secret"])

Guides

Building a full-stack app with a database

This guide walks through creating a project, provisioning a database, deploying a worker, and binding them together.

# 1. Create the project
helix init my-project/api
cd my-project/api

# 2. Provision a database
helix db create primary

# 3. Add the binding to helix.json
# "bindings": [{ "type": "db", "name": "DB", "resource": "primary" }]

# 4. Write your worker
cat <<'EOF' > src/worker.ts
export default {
  async fetch(request: Request, env: any) {
    // Initialize tables on first request
    await env.DB.exec(`
      CREATE TABLE IF NOT EXISTS visits (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        path TEXT, visited_at TEXT DEFAULT (datetime('now'))
      )
    `);

    const url = new URL(request.url);
    await env.DB.prepare("INSERT INTO visits (path) VALUES (?)").bind(url.pathname).run();

    const { results } = await env.DB.prepare(
      "SELECT path, COUNT(*) as count FROM visits GROUP BY path ORDER BY count DESC LIMIT 10"
    ).all();

    return Response.json({ top_pages: results });
  }
};
EOF

# 5. Deploy
helix deploy

Building an app with object storage

# Provision a bucket
helix bucket create uploads

# helix.json bindings:
# { "type": "bucket", "name": "UPLOADS", "resource": "uploads" }

# In your worker:
export default {
  async fetch(request: Request, env: any) {
    const url = new URL(request.url);

    if (request.method === "PUT") {
      const key = url.pathname.slice(1);
      await env.UPLOADS.put(key, request.body, {
        httpMetadata: { contentType: request.headers.get("content-type") || "application/octet-stream" },
      });
      return Response.json({ ok: true, key });
    }

    if (request.method === "GET") {
      const key = url.pathname.slice(1);
      const obj = await env.UPLOADS.get(key);
      if (!obj) return new Response("Not found", { status: 404 });
      return new Response(obj.body, {
        headers: { "Content-Type": obj.httpMetadata?.contentType || "application/octet-stream" },
      });
    }

    return new Response("Method not allowed", { status: 405 });
  }
};

Building an app with KV caching

# Provision a KV store
helix kv create cache

# helix.json bindings:
# { "type": "kv", "name": "CACHE", "resource": "cache" }

# In your worker:
export default {
  async fetch(request: Request, env: any) {
    const url = new URL(request.url);
    const cacheKey = `page:${url.pathname}`;

    // Check cache first
    const cached = await env.CACHE.get(cacheKey);
    if (cached) {
      return new Response(cached, {
        headers: { "Content-Type": "text/html", "X-Cache": "HIT" },
      });
    }

    // Generate response
    const html = `<h1>Hello from ${url.pathname}</h1><p>Generated at ${new Date().toISOString()}</p>`;

    // Cache for 5 minutes
    await env.CACHE.put(cacheKey, html, { expirationTtl: 300 });

    return new Response(html, {
      headers: { "Content-Type": "text/html", "X-Cache": "MISS" },
    });
  }
};

CI/CD with GitHub Actions

# .github/workflows/deploy.yml
name: Deploy
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - run: npm run build
      - name: Deploy to Cirrus Host
        env:
          HELIX_TOKEN: ${{ secrets.HELIX_TOKEN }}
        run: |
          curl -X POST https://cirrus-host.com/api/v1/projects/my-api/deployments \
            -H "Authorization: Bearer $HELIX_TOKEN" \
            -F "bundle=@dist/worker.js" \
            -F 'metadata={"name":"api","message":"'"$GITHUB_SHA"'"}'

curl -X POST https://cirrus-host.com/api/v1/api-keys \
  -H "Authorization: Bearer $ADMIN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"GitHub Actions","scopes":["deployments:write","projects:read"],"allowed_projects":["my-api"]}'

Deploying a container

# Deploy a Ghost CMS container
curl -X POST https://cirrus-host.com/api/v1/projects/my-blog/deployments/container \
  -H "Authorization: Bearer $HELIX_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ghost",
    "image": "ghost:5",
    "port": 2368,
    "size": "shared-cpu-1x@1024mb",
    "env": {
      "url": "https://ghost.my-blog.helx.dev",
      "database__client": "sqlite3"
    }
  }'