Coolify

Name: Coolify API
Brand: Coolify
Availability: InStock

★ Only Publicly Available OpenAPI DocumentDeveloper ToolsCi Cdbearer134 EndpointsREST

For Agents

Deploy and manage applications, databases, and services on Coolify across self-hosted or cloud instances. Agents authenticate with a bearer API token from Keys and Tokens.

Quickstart

Get started with Coolify in minutes using your preferred integration method.

# Add to your MCP client config (Claude Desktop, Cursor, Windsurf)
{
  "jentic": {
    "url": "https://api.jentic.com/mcp",
    "auth": "oauth"
  }
}

# Then ask your agent:
"deploy a coolify application from github"

# → Jentic returns the GET /events tool with parameter schema, agent executes.

Capabilities

What an agent can do with Coolify API.

Create applications from public or private GitHub repos, Dockerfiles, Docker images, or Docker Compose via the /applications POST endpoints

Start, stop, and restart applications via /applications/{uuid}/start, /stop, and /restart

Manage environment variables individually or in bulk via /applications/{uuid}/envs and /envs/bulk

Provision and manage persistent storage volumes for applications via /applications/{uuid}/storages

GET STARTED

Start building with Coolify API

Explore with Jentic

View OpenAPI Document

Jentic publishes the only available OpenAPI document for Coolify, keeping it validated and agent-ready.

Jentic publishes the only available OpenAPI specification for Coolify, keeping it validated and agent-ready. Coolify is an open-source, self-hostable platform for deploying applications, databases, and services from Git, Dockerfile, Docker image, or Docker Compose definitions. The 134 endpoints cover application lifecycle, environment variables, storage volumes, cloud provider tokens, databases, services, projects, servers, teams, and team members. Authentication is a bearer API token created from the Coolify dashboard's Keys and Tokens section, and the same API works against Coolify Cloud or any self-hosted instance.

Use Cases

Patterns agents use Coolify API for, with concrete tasks.

★ Self-Hosted Deployment Automation

Replace manual SSH-and-docker-compose with API-driven deployments on a self-hosted Coolify server. POST /applications/public creates the app from a Git repo, /applications/{uuid}/envs sets configuration, and /applications/{uuid}/start launches it. Suited to engineering teams running Coolify as their internal Heroku and wanting deploys triggered from CI rather than the dashboard.

Create an application from https://github.com/acme/web on the production server, set DATABASE_URL via POST /applications/{uuid}/envs, then call /applications/{uuid}/start

Database Provisioning for Preview Environments

Spin up disposable Postgres or Redis instances per pull request via the /databases endpoints, attach them to a freshly deployed application, and tear everything down when the branch is merged. Coolify's API treats databases as first-class resources with their own lifecycle endpoints. Useful for engineering teams running real preview environments with isolated data per branch.

Create a Postgres database for PR #4123, capture its connection string, set it on the preview application's envs, and start the application

Multi-Server Application Lifecycle Management

Operate a fleet of Coolify servers across regions or clients by listing servers, projects, and applications through the API and pushing lifecycle commands centrally. The /servers, /projects, and /applications endpoints surface state, and /teams plus /team-members manage access. Useful for agencies and platform teams running Coolify on behalf of customers.

List all servers and applications, then restart any application whose latest deployment status is 'failed'

Agent-Driven Deployment Workflows via Jentic

An AI agent operates a Coolify instance through Jentic — creating applications, setting envs, and running lifecycle commands — without holding the API token. The agent searches Jentic for the deploy intent, loads the schema, and orchestrates the multi-step flow. Through Jentic the bearer token is held in the vault so deployment automation runs without secret exposure.

Search Jentic for 'deploy a coolify application', load the schema, then create a Node.js app from a Git repo, set NODE_ENV=production, and start it

Key Endpoints

134 endpoints — jentic publishes the only available openapi specification for coolify, keeping it validated and agent-ready.

METHOD

PATH

DESCRIPTION

GET

/applications

List applications

POST

/applications/public

Create an application from a public Git repo

POST

/applications/dockercompose

Create an application from a Docker Compose file

GET

/applications/{uuid}/start

Start an application

GET

/applications/{uuid}/logs

Get application logs

POST

/applications/{uuid}/envs

Create an environment variable on an application

GET

/databases

List databases

GET

/applications

List applications

POST

/applications/public

Create an application from a public Git repo

POST

/applications/dockercompose

Create an application from a Docker Compose file

GET

/applications/{uuid}/start

Start an application

GET

/applications/{uuid}/logs

Get application logs

Why though Jentic?

Three things that make agents converge on Jentic-routed access.

Credential isolation

Coolify bearer tokens are stored encrypted in the Jentic vault. Agents receive scoped access at execution time and the token is injected into the Authorization header — raw tokens never enter the agent's context window.

Intent-based discovery

Agents search Jentic by intent (e.g., 'deploy a coolify application' or 'restart a coolify service') and Jentic returns the matching /applications, /databases, or /services operation with its input schema.

Time to first call

Direct Coolify integration: 1-2 days across 134 endpoints, application lifecycle, env management, and storage volumes. Through Jentic: under 1 hour — search, load, execute the chained flow.

Related APIs

Alternatives and complements available in the Jentic catalogue.

Alternative

Render API

Hosted PaaS for deploying web services and databases, similar deploy primitives to Coolify Cloud.

Choose Render when teams want a fully managed PaaS; pick Coolify when self-hosting or open-source control matters.

Alternative

Railway API

Hosted developer platform for deploying apps and databases from Git or Docker.

Choose Railway when low-friction managed hosting is preferred; pick Coolify for full control over the underlying servers.

Complementary

DigitalOcean API

Cloud infrastructure provider that often hosts the underlying servers a self-hosted Coolify runs on.

Pair with Coolify when an agent needs to provision the Droplet that Coolify will run on, then drive deployments via Coolify.

FAQs

Specific to using Coolify API through Jentic.

Why is there no official OpenAPI spec for Coolify?

Coolify does not publish a maintained OpenAPI specification covering every endpoint. Jentic generates and maintains this spec so that AI agents and developers can call Coolify via structured tooling. It is validated against the live API and kept up to date. Get started at https://app.jentic.com/sign-up.

What authentication does the Coolify API use?

Coolify uses HTTP bearer authentication. Generate a token in the Coolify dashboard under Keys and Tokens / API tokens and send it as Authorization: Bearer on every call. Through Jentic the token is stored encrypted in the vault and injected at execution time so it never enters the agent's prompt.

Can the Coolify API deploy an application from a private GitHub repo?

Yes. POST /applications/private-github-app deploys from a private repo via a configured GitHub App, and POST /applications/private-deploy-key deploys using a deploy key. Use POST /applications/public for public repos and POST /applications/dockerfile or /dockerimage for non-Git sources.

Does the Coolify API work with self-hosted instances?

Yes. The base URL on Coolify Cloud is https://app.coolify.io/api/v1, but the same API runs on every self-hosted Coolify instance — point requests at https://your-coolify-host/api/v1 and use a token generated on that instance.

How do I update many environment variables at once?

PATCH /applications/{uuid}/envs/bulk accepts an array of env updates so dozens of variables can be changed in a single call. This is faster than iterating through PATCH /applications/{uuid}/envs per variable when reseeding configuration after a config-as-code change.

What are the rate limits for the Coolify API?

Rate limits are not declared in the OpenAPI spec. Self-hosted instances do not impose any out of the box, while Coolify Cloud applies plan-level limits — back off on HTTP 429 responses. Contact Coolify support for documented limits applicable to your plan.

How do I deploy an application through Jentic?

Run jentic search for 'deploy a coolify application', load the POST /applications/public (or /dockercompose) operation, then execute it with the Git repo, project, and server UUIDs. Chain in /applications/{uuid}/envs and /applications/{uuid}/start to set configuration and launch the deploy. Jentic injects the bearer token from the vault.