Apps API

Apps is part of App Deployment now. Every app is a deployment, listed as a Web service, or as a Static site or a Hybrid site for one that builds a site, and its page under App Deployment in the dashboard holds its releases, instances, domains and variables. The Apps API keeps answering as it did, so a script written for Apps keeps working: your own apps are under /api/v1/client/apps, and an organization's under /api/v1/orgs/{org_slug}/apps. These pages document it.

An app runs a web service from its source: a git repository that we build an image from, or a container image that is already built. It suits a website, an API or any other service that answers HTTP and keeps its data somewhere else, such as a database or Object Storage.

For something new, start from App Deployment instead: Deploy from a git repository in the dashboard, or the deployments API under /api/v1/client/deployments, which also reaches previews, environments, locations and billing. Container Apps and Apps in App Deployment says what moved where.

The Apps API keeps the words Apps used for an app, a replica, a region and the platform name, and these pages use them too. A version of an app is a release on these pages, as it is in the dashboard. The API names a release deployment, in its objects, its paths and its field names, and these pages write that name only in code.

• A source: a git repository and branch, or a container image. You choose it when you create the app, and it cannot change later.
• For a git app, settings for the build: the directory in the repository, the framework, and the commands to install, build and start.
• A size, which sets the memory, CPU and disk of each replica.
• The regions it runs in, and how many replicas run in each.
• Environment variables, each for the build, the running app or both.
• A platform name, <name>.<app domain>, and up to 20 custom domains, each with a certificate.
• For a git app, a push webhook that deploys each push to the app's branch.
• A history of releases. You can roll back to any of them that went live.

How the Apps API runs an app explains how these fit together.

Set up an app:

• Create an app with the Apps API from a repository or an image
• Set environment variables with the Apps API for the build and the running app
• Add a custom domain with the Apps API and verify it with a TXT record
• Deploy on every push with the push webhook

Ship and run it:

• Deploy an app with the Apps API: a branch, a commit or an image, a redeploy, a rebuild, or cancelling a release
• Read a release and its build log with the Apps API
• Roll back to an earlier release with the Apps API
• Change or delete an app with the Apps API
• Run apps for an organization

Look things up and fix problems:

• App and release fields
• Apps API limits
• Troubleshoot the Apps API

Select App Deployment in the sidebar to open your deployments, then select Web services in place of All to see only your apps (Your deployments). Select one to open its page. What these pages do through the API is on its tabs:

Releases

Its releases, newest first, each with its build log, and Deploy a branch…, Rebuild…, Redeploy… and Roll back to this… (Deploy, promote and roll back releases).

Instances

Its replicas in each region, where it runs and how it scales (Choose locations and scaling).

Domains

The platform address and the custom domains (Add a domain and protection).

Variables

Its variables, for every environment or for one (Environments and variables).

Settings

Its name, how it builds and runs, and deleting it (Change or delete a deployment).

An app is billed as any web service is: by what its replicas use, with some use free each month and no price of its own. Its size becomes its starting memory limit. Its Billing tab shows how it is billed now (How App Deployment is billed). An app that was billed on pay as you go or monthly before usage billing keeps those terms until you move it. The Apps API does not read or change billing: the billing requests under /api/v1/billing/deployments/{deployment_uuid} take the app's uuid.

• Apps can be turned off for the whole platform. While it is off, every Apps API request answers 404 with {"detail": "Not Found"}, whoever sends it, and App Deployment offers only game servers and databases.
• Visitors reach an app only through its domains. A replica has no public address of its own.
• A new release starts on new replicas, so files an app writes to its disk do not carry over.
• The Apps API reads a release's build log. What the app writes while it runs is on its Logs tab (Logs and metrics).
• Your account and each organization can create a set number of apps through the Apps API, which GET /api/v1/client/apps/regions gives with how many you have.

Apps API limits lists every limit.

An organization can own apps too. Its apps use the same requests under /api/v1/orgs/{org_slug}/apps, with the same bodies, answers and errors as your own apps under /api/v1/client/apps. Any member of the organization can read them. Only an owner or an admin can create, change, deploy or delete one, and any other member gets 403 with Admin access required. Organization roles and permissions describes the roles.

Deleting an organization's app also needs the app's name typed to confirm it. From a staff console session, it needs a step-up in the last 10 minutes as well (Confirm it is you). Each change a member makes to an organization's app goes into the organization's audit log, which names the member. The log leaves out releases that a push starts.

In the dashboard, an organization's apps are under App Deployment beside your own, and on its App Deployment tab: Run apps for an organization.

Every Apps request takes your access token as Authorization: Bearer $CORITAN_TOKEN (Authentication). Your own apps are under /api/v1/client/apps. An organization's apps are under /api/v1/orgs/{org_slug}/apps, and take the token of one of its members. An app that belongs to someone else answers 404 with App not found, as an app that does not exist does, and so does the ID of a game server or a database.

GET /api/v1/client/apps lists your apps, newest first, each with its live release and replica counts:

curl "https://api.coritan.com/api/v1/client/apps?status=active&limit=20" \
  -H "Authorization: Bearer $CORITAN_TOKEN"

{
  "apps": [
    {
      "uuid": "3c9e2f4a-8b1d-4f6e-a2c7-5d8b9e0f1a21",
      "name": "Web shop",
      "slug": "web-shop",
      "status": "active",
      "owner": {"type": "user"},
      "source_type": "git",
      "repo_url": "https://github.com/example/web-shop",
      "repo_branch": "main",
      "repo_subdir": null,
      "repo_token_set": true,
      "repo_token_hint": "x9Qa",
      "image_ref": null,
      "framework": null,
      "install_command": null,
      "build_command": null,
      "start_command": null,
      "dockerfile_path": null,
      "port": 3000,
      "health_check_path": "/healthz",
      "instance_size": "small",
      "memory_mb": 512,
      "cpu_percent": 100,
      "disk_mb": 2048,
      "regions": ["fra", "iad"],
      "min_replicas": 2,
      "max_replicas": 2,
      "url": "https://web-shop.apps.example.net",
      "platform_hostname": "web-shop.apps.example.net",
      "domains_count": 2,
      "current_deployment": {
        "uuid": "8c4e1a7d-2f9b-4d6e-b3a8-6e1f9c2d5a10",
        "status": "ready",
        "source": "git",
        "trigger": "push",
        "git_ref": "main",
        "git_sha": "9f2c1e7b4a6d8e0f1a2b3c4d5e6f708192a3b4c5",
        "is_current": true
      },
      "replicas": {"healthy": 4, "unhealthy": 0, "starting": 0, "total": 4},
      "webhook": {
        "url": "https://api.coritan.com/api/v1/apps/hooks/3c9e2f4a-8b1d-4f6e-a2c7-5d8b9e0f1a21",
        "secret_set": true,
        "secret_hint": "f0a9"
      },
      "created_at": "2026-09-20T09:12:00Z",
      "updated_at": "2026-09-26T10:05:00Z"
    }
  ],
  "total": 1,
  "limit": 20,
  "offset": 0
}

status is active or suspended, and leaving it out lists every app, those a spend limit has paused included. limit takes 1–100 (50 when left out), and offset skips that many apps. total counts every app the filter matches. The example shortens current_deployment, the live release, which carries every field of a release. App and release fields describes each field.

The examples on these pages use apps.example.net for the platform's app domain. base_domain in the regions answer below gives the real one.

GET /api/v1/client/apps/{app_uuid} returns the app with more beside it:

app

The app, as in the list.

domains

Its platform name first, then its custom domains (Add a custom domain).

deployments and deployments_total

The five newest releases, and how many the app has in all (List releases).

replicas

The replicas of the live release, without the ones that failed (Read a release).

curl https://api.coritan.com/api/v1/client/apps/3c9e2f4a-8b1d-4f6e-a2c7-5d8b9e0f1a21 \
  -H "Authorization: Bearer $CORITAN_TOKEN"

GET /api/v1/client/apps/regions says what you can choose when you create an app:

curl https://api.coritan.com/api/v1/client/apps/regions \
  -H "Authorization: Bearer $CORITAN_TOKEN"

{
  "regions": [
    {"code": "fra", "name": "Frankfurt", "country_code": "DE"},
    {"code": "iad", "name": "Ashburn", "country_code": "US"}
  ],
  "sizes": [
    {"name": "small", "memory_mb": 512, "cpu_percent": 100, "disk_mb": 2048},
    {"name": "medium", "memory_mb": 1024, "cpu_percent": 200, "disk_mb": 4096},
    {"name": "large", "memory_mb": 2048, "cpu_percent": 400, "disk_mb": 8192}
  ],
  "base_domain": "apps.example.net",
  "limits": {
    "apps": 20,
    "apps_used": 3,
    "min_replicas": 5,
    "max_replicas": 10,
    "regions": 20,
    "custom_domains": 20,
    "env_vars": 200
  }
}

regions lists the regions that can run apps now. base_domain is the domain every platform name ends in, or null when the platform gives apps no platform name. In limits, apps is how many apps you may have, where 0 means no limit, and apps_used is how many you have. min_replicas and max_replicas are the most you can set for each, and the rest are the most regions, custom domains and variables one app can have.

The same three requests under /api/v1/orgs/{org_slug}/apps read an organization's apps, and there limits.apps_used counts the organization's apps. The organization apps reference lists them.