---
title: "create_application"
description: "Generated reference for the management action create_application: its description, access metadata, payload contract, and registration status."
slug: /reference/actions/create-application
order: 12
visibility: public
redirects_from: []
---

# create\_application

Generated automatically from the [published contract sources](/cloud/reference/about/#contract-sources).

A script calls this action over HTTPS at `POST https://tzcloud.turnzero.ai/v1/create_application`, with a bearer credential and the action's payload as the JSON body. An MCP connection lists this action as the tool `tzcloud_create_application`.

OAuth access tokens and minted tokens, including the turnzero command's computer token, are bearer credentials. The action determines which kinds, scopes and grants it accepts ([Sign-in, sessions, and tokens](/cloud/concepts/sign-in-sessions-and-tokens/)).

**Build metadata:** Registered in this build. Registration describes the default dispatcher in this build. It does not guarantee that a caller has the required credential or grant, that a tool is listed for that connection, or that the required service is configured.

## Contract description

Creates your application\. Hostnames are `<label>` \(production\) and `<label>-dev` \(development\)\.

A site of static files alone takes `kind` `serverless` and no `size`, with the reason told to the owner in one line\. It runs no code\. Code takes the owner's `size`, `shared-0.5gb` or `shared-1gb`, chosen before this call\. With nobody to ask and no size in the task, `shared-0.5gb` is passed and the choice reported\.

Both sizes cost by use\. Each draws the account's monthly free usage, shared by all its applications and every other line\. No money is charged while credits are not sold\. `read_rate_card` gives rates and `read_balance` what remains\.

`submit_manifest` precedes the first deploy\. Production alone exists at creation\. Development is added with `create_environment` only if the owner asks to try versions first\. `account-application-limit` applies except under the super\-admin grant or for unbilled accounts\.

## More about this action

This call creates the application's record only\. Its services are declared with `submit_manifest` before the first `deploy`\. A new application has production alone, so that deploy serves production\. Production alone is used unless the owner asks to try versions on development first, added with `create_environment`\.

For a site of static files alone, the choice is serverless, with the reason told to the owner in one line\. A serverless application is charged only for what it serves\. A serverless creation takes `name` and `kind` set to `serverless`, with no `size`\. It serves the files under `client/` and runs no code\. A serverless manifest submission declaring a database, schedule or egress host refuses 403 `serverless_static_only`\. A deploy refuses the same declarations in the recorded manifest, or a `functions/` or `migrations/` folder, with that error\. A storage area may be declared\.

An application running code on the platform takes a server\. A server has its own container and draws usage for the time it is awake\. The account's owner chooses `size` before a server is created\. With nobody to ask and no size in the task, `shared-0.5gb` is passed and the choice reported\. A server creation takes `size` with `kind` set to `server` or omitted\. `shared-0.5gb` is smaller; `shared-1gb` gives more memory or CPU\. Each size draws the account's monthly free usage first, at its own rate\. Size sets replica memory, CPU and production placement\. `read_plan_quotas` returns the sizes' quota rows\.

Both sizes cost by use\. The account's monthly free usage is shared by all its applications and every other line, including storage, data transfer, email, AI and monthly items\. `read_balance` shows what remains, including any launch bonus\. During the introduction period, while credits are not sold, nothing is charged in money\. When a billed account uses its whole balance, its applications pause, except unlimited and operated applications\. The next month or a live grant ends the pause\. An application within the account's monthly free usage needs no card\.

On `read_rate_card`, `monthly-free-usage` is dollars for an account for a UTC month\. Production's awake time draws `server-shared-0.5gb` or `server-shared-1gb`, each dollars for a month of awake time\. A server awake for part of the month draws that part of its monthly rate\. Development's awake time draws `server-shared-0.5gb` whatever the production size\. A shared database adds `database-shared`, a monthly item per application\. One added during a month draws for the days left; removing it gives nothing back\. The server keys, any database and all other lines share the account's balance\.

On production, `shared-0.5gb` sleeps when idle by default\. On production, `shared-1gb` has sleep off by default, so it keeps one warm replica and is awake the whole month\. The owner can change production's sleep setting\. An application moved from the old Standard plan keeps that setting off\. A sleeping environment stops after the idle period and takes a cold first request\. An environment with sleep off is awake the whole month\. Development always sleeps when idle and has no switch\.

`name` is the readable name\. `label` is `name` plus a unique key\. Hostnames are `<label>` for production and `<label>-dev` for development on the platform's domain\. The answer's `id` is the `application` value for later calls\. The answer includes `size` for a server and omits it for a serverless application\.

An unknown kind, a `plan`, a serverless creation with `size`, or a request naming neither size nor serverless kind refuses `invalid_request` before any write\. A size whose quantity is unset refuses `plan_quantity_unset`\. A creation past `account-application-limit` refuses `account_application_limit`\. That limit does not apply under the super\-admin grant or on an unbilled account\. The answer then includes `application_limit_exemption`, `super_admin` or `unbilled`; otherwise that member is absent\.

## Access and action metadata

```json
{
  "name": "create_application",
  "resource": "application",
  "tier": "reversible",
  "surface": "tzcloud",
  "addresses": [
    "tzcloud"
  ],
  "product": "cloud",
  "summary": "Create an application for the account.",
  "annotations": {
    "readOnlyHint": false,
    "destructiveHint": false,
    "openWorldHint": false
  }
}
```

## MCP catalog entry

```json
{
  "name": "create_application",
  "title": "Create application",
  "tier": "reversible",
  "scenario": "CHI-L0-07",
  "summary": "Creates your application. Hostnames are `<label>` (production) and `<label>-dev` (development).\n\nA site of static files alone takes `kind` `serverless` and no `size`, with the reason told to the owner in one line. It runs no code. Code takes the owner's `size`, `shared-0.5gb` or `shared-1gb`, chosen before this call. With nobody to ask and no size in the task, `shared-0.5gb` is passed and the choice reported.\n\nBoth sizes cost by use. Each draws the account's monthly free usage, shared by all its applications and every other line. No money is charged while credits are not sold. `read_rate_card` gives rates and `read_balance` what remains.\n\n`submit_manifest` precedes the first deploy. Production alone exists at creation. Development is added with `create_environment` only if the owner asks to try versions first. `account-application-limit` applies except under the super-admin grant or for unbilled accounts.",
  "owners": [
    "ACB-L0-22",
    "PRC-L0-04",
    "ACB-L0-83",
    "ACB-L0-84",
    "PRC-L0-05",
    "ACB-L0-26"
  ]
}
```

## request

| JSON pointer | Description and constraints |
|---|---|
| "" \(root\) | Type: object<br>Required fields: \["name"\]<br>Retired members: plan: `plan` is no longer passed: use `size`, `shared-0.5gb` or `shared-1gb`\. |
| /<wbr>properties/<wbr>name | A lowercase slug such as `todo-api`\. Use 1 to 40 characters\. Start with a lowercase letter, then use lowercase letters, digits, or hyphens\. The slug becomes the readable part of the application's hostname\. The platform adds a unique key\.<br><br>Type: string<br>Pattern: ^\[a\-z\]\[a\-z0\-9\-\]\{0,39\}$ |
| /<wbr>properties/<wbr>size | A server's size: shared\-0\.5gb or shared\-1gb\. It sets replica memory, CPU and production placement\. `read_plan_quotas` returns the sizes' quota rows\. The owner chooses it\. With none chosen and nobody to ask, shared\-0\.5gb is passed and reported\. A serverless application takes no size\.<br><br>Type: string<br>Allowed values: \["shared\-0\.5gb","shared\-1gb"\] |
| /<wbr>properties/<wbr>kind | The kind is server or serverless\. A server has its own container and takes a size\. A serverless application serves static files alone, runs no code and takes no size\. Leaving kind out selects server, which also requires `size`\.<br><br>Type: string<br>Allowed values: \["serverless","server"\] |

## response

| JSON pointer | Description and constraints |
|---|---|
| "" \(root\) | Type: object<br>Required fields: \["contract\_version","application","outcome"\] |
| /<wbr>properties/<wbr>contract\_version | Required value: 1 |
| /<wbr>properties/<wbr>reference | The short reference the platform recorded your call under: ten lowercase hexadecimal characters, the value in the call’s record row\. Quote it when you report the call\.<br><br>Type: string<br>Pattern: ^\[0\-9a\-f\]\{10\}$ |
| /<wbr>properties/<wbr>application | id, name, label, created\_at, size, and kind\. A server includes the size passed at creation\. A serverless application omits size\. The kind is server or serverless\.<br><br>Type: object |
| /<wbr>properties/<wbr>outcome | Type: string<br>Pattern: ^created$ |
| /<wbr>properties/<wbr>application\_limit\_exemption | Present only where the call's credential and account pass the account's application limit: `super_admin` under the super\-admin grant, `unbilled` for an account carrying the mark\. Absent otherwise\.<br><br>Type: string<br>Allowed values: \["super\_admin","unbilled"\] |
| /<wbr>properties/<wbr>detail | Says the next step, the manifest then the deploy, and that the new application has production alone, so taking it to production is a deploy\. It directs the caller to use production alone unless the owner asks to try versions before they serve; only then is create\_environment called before deploying, followed by promote\. The page at `page` explains each step\.<br><br>Type: string |
| /<wbr>properties/<wbr>page | $ref: \#/shapes/page |
| /<wbr>properties/<wbr>dashboard | The full address of the new application’s dashboard page\. The person who holds its account can open it after signing in\.<br><br>Type: string |
| /<wbr>properties/<wbr>next | Calls with `action` and `arguments`, in order: `submit_manifest`, `deploy_command`, then `read_rate_card` for costs\. Add `manifest` to the first call\. Read rates before deploying\. A serverless creation omits `deploy_command`\.<br><br>Type: array |
| /<wbr>properties/<wbr>next/<wbr>items | Type: object<br>Required fields: \["action","arguments"\]<br>Additional properties: false |
| /<wbr>properties/<wbr>next/<wbr>items/<wbr>properties/<wbr>action | Allowed values: \["submit\_manifest","deploy\_command","read\_rate\_card"\] |
| /<wbr>properties/<wbr>next/<wbr>items/<wbr>properties/<wbr>arguments | Type: object<br>Additional properties: false |
| /<wbr>properties/<wbr>next/<wbr>items/<wbr>properties/<wbr>arguments/<wbr>properties/<wbr>application | Type: string |

## Complete payload contract

```json
{
  "request": {
    "type": "object",
    "required": [
      "name"
    ],
    "properties": {
      "name": {
        "type": "string",
        "pattern": "^[a-z][a-z0-9-]{0,39}$",
        "description": "A lowercase slug such as `todo-api`. Use 1 to 40 characters. Start with a lowercase letter, then use lowercase letters, digits, or hyphens. The slug becomes the readable part of the application's hostname. The platform adds a unique key."
      },
      "size": {
        "type": "string",
        "enum": [
          "shared-0.5gb",
          "shared-1gb"
        ],
        "description": "A server's size: shared-0.5gb or shared-1gb. It sets replica memory, CPU and production placement. `read_plan_quotas` returns the sizes' quota rows. The owner chooses it. With none chosen and nobody to ask, shared-0.5gb is passed and reported. A serverless application takes no size."
      },
      "kind": {
        "type": "string",
        "enum": [
          "serverless",
          "server"
        ],
        "description": "The kind is server or serverless. A server has its own container and takes a size. A serverless application serves static files alone, runs no code and takes no size. Leaving kind out selects server, which also requires `size`."
      }
    },
    "x-retired": {
      "plan": "`plan` is no longer passed: use `size`, `shared-0.5gb` or `shared-1gb`."
    }
  },
  "response": {
    "type": "object",
    "required": [
      "contract_version",
      "application",
      "outcome"
    ],
    "properties": {
      "contract_version": {
        "const": 1
      },
      "reference": {
        "type": "string",
        "pattern": "^[0-9a-f]{10}$",
        "description": "The short reference the platform recorded your call under: ten lowercase hexadecimal characters, the value in the call’s record row. Quote it when you report the call."
      },
      "application": {
        "type": "object",
        "description": "id, name, label, created_at, size, and kind (ACB-L0-22). A server includes the size passed at creation. A serverless application omits size. The kind is server or serverless."
      },
      "outcome": {
        "type": "string",
        "pattern": "^created$"
      },
      "application_limit_exemption": {
        "type": "string",
        "enum": [
          "super_admin",
          "unbilled"
        ],
        "description": "Present only where the call's credential and account pass the account's application limit: `super_admin` under the super-admin grant, `unbilled` for an account carrying the mark. Absent otherwise (ACB-L0-84)."
      },
      "detail": {
        "type": "string",
        "description": "Says the next step, the manifest then the deploy, and that the new application has production alone, so taking it to production is a deploy. It directs the caller to use production alone unless the owner asks to try versions before they serve; only then is create_environment called before deploying, followed by promote (PLD-L0-96). The page at `page` explains each step."
      },
      "page": {
        "$ref": "#/shapes/page"
      },
      "dashboard": {
        "type": "string",
        "description": "The full address of the new application’s dashboard page. The person who holds its account can open it after signing in."
      },
      "next": {
        "type": "array",
        "items": {
          "type": "object",
          "required": [
            "action",
            "arguments"
          ],
          "properties": {
            "action": {
              "enum": [
                "submit_manifest",
                "deploy_command",
                "read_rate_card"
              ]
            },
            "arguments": {
              "type": "object",
              "properties": {
                "application": {
                  "type": "string"
                }
              },
              "additionalProperties": false
            }
          },
          "additionalProperties": false
        },
        "description": "Calls with `action` and `arguments`, in order: `submit_manifest`, `deploy_command`, then `read_rate_card` for costs. Add `manifest` to the first call. Read rates before deploying. A serverless creation omits `deploy_command`."
      }
    }
  }
}
```

## Shared contracts

- [Refusals](/cloud/reference/refusals/): every refusal, by surface, with its cause and its remedy
- [schemas/wire\_error\.schema\.json](/cloud/reference/sources/schemas/wire-error-schema/)
- [schemas/wire\_errors\.json](/cloud/reference/sources/schemas/wire-errors/)
- [schemas/action\_payloads\.json](/cloud/reference/sources/schemas/action-payloads/) (includes shared shapes)
- [management\_api\_contract\.md](/cloud/reference/sources/management-api-contract/)
