CLI for Coolify API

Installation

Install script (recommended)

Linux/macOS

curl -fsSL https://raw.githubusercontent.com/coollabsio/coolify-cli/main/scripts/install.sh | bash

It will install the CLI in /usr/local/bin/coolify and the configuration file in ~/.config/coolify/config.json

Homebrew (macOS/Linux)

brew install coollabsio/coolify-cli/coolify-cli

Windows (PowerShell)

irm https://raw.githubusercontent.com/coollabsio/coolify-cli/main/scripts/install.ps1 | iex

It will install the CLI in %ProgramFiles%\Coolify\coolify.exe and the configuration file in %USERPROFILE%\.config\coolify\config.json

For user installation (no admin rights required):

$env:COOLIFY_USER_INSTALL=1; irm https://raw.githubusercontent.com/coollabsio/coolify-cli/main/scripts/install.ps1 | iex

For a specific version:

$env:COOLIFY_VERSION='v1.0.0'; irm https://raw.githubusercontent.com/coollabsio/coolify-cli/main/scripts/install.ps1 | iex

Using go install

go install github.com/coollabsio/coolify-cli/coolify@latest

This will install the coolify binary in your $GOPATH/bin directory (usually ~/go/bin). Make sure this directory is in your $PATH.

Using the install script

Getting Started

1. Get a <token> from your Coolify dashboard (Cloud or self-hosted) at /security/api-tokens

Cloud

2. Add the token with coolify context set-token cloud <token>

Self-hosted

2. Add the token with coolify context add -d <context_name> <url> <token>

Replace <context_name> with the name you want to give to the context.

Replace <url> with the fully qualified domain name of your Coolify instance.

Now you can use the CLI with the token you just added.

For LLMs / AI agents

• Quick instructions: llms.txt
• Full command catalog: llms-full.txt
• Regenerate both files:

go run ./coolify docs llms

Change default context

You can change the default context with coolify context use <context_name> or coolify context set-default <context_name>

Currently Supported Commands

Update

• coolify update - Update the CLI to the latest version

Version

• coolify version - Show the current CLI version

Configuration

• coolify config - Show configuration file location

Shell Completion

• coolify completion <shell> - Generate shell completion script
  • Supported shells: bash, zsh, fish, powershell

Context Management

• coolify context list - List all configured contexts
• coolify context add <context_name> <url> <token> - Add a new context
  • -d, --default - Set as default context
  • -f, --force - Force overwrite if context already exists
• coolify context delete <context_name> - Delete a context
• coolify context get <context_name> - Get details of a specific context
• coolify context set-token <context_name> <token> - Update the API token for a context
• coolify context set-default <context_name> - Set a context as the default
• coolify context update <context_name> - Update a context's properties
  • --name <new_name> - Change the context name
  • --url <new_url> - Change the context URL
  • --token <new_token> - Change the context token
• coolify context use <context_name> - Switch to a different context (set as default)
• coolify context verify - Verify current context connection and authentication
• coolify context version - Get the Coolify API version of the current context

Servers

Commands can use server or servers interchangeably.

• coolify server list - List all servers
• coolify server get <uuid> - Get a server by UUID
  • --resources - Get the resources and their status of a server
• coolify server add <name> <ip> <private_key_uuid> - Add a new server
  • -p, --port <port> - SSH port (default: 22)
  • -u, --user <user> - SSH user (default: root)
  • --validate - Validate server immediately after adding
• coolify server remove <uuid> - Remove a server
• coolify server validate <uuid> - Validate a server connection
• coolify server domains <uuid> - Get server domains by UUID
• coolify server destinations list <server_uuid> - List a server's destinations
• coolify server destinations create <server_uuid> - Create a server destination
• coolify server hetzner|digitalocean|vultr - List provider options and provision a server

Projects

• coolify projects list - List all projects
• coolify projects get <uuid> - Get project environments
• coolify projects create - Create a new project
  • --name <name> - Project name (required)
  • --description <description> - Project description

Resources

• coolify resources list - List all resources

Applications

• coolify app list - List all applications
• coolify app get <uuid> - Get application details
• coolify app update <uuid> - Update application configuration
  • --name <name> - Application name
  • --description <description> - Application description
  • --git-branch <branch> - Git branch
  • --git-repository <url> - Git repository URL
  • --domains <domains> - Domains (comma-separated)
  • --compose-domain <service>=<url>[,<url>] - Docker Compose service domains (repeatable; update replaces the existing mapping)
  • --build-command <cmd> - Build command
  • --start-command <cmd> - Start command
  • --install-command <cmd> - Install command
  • --base-directory <path> - Base directory
  • --publish-directory <path> - Publish directory
  • --dockerfile <content> - Dockerfile content
  • --docker-image <image> - Docker image name
  • --docker-tag <tag> - Docker image tag
  • --ports-exposes <ports> - Exposed ports
  • --ports-mappings <mappings> - Port mappings
  • --health-check-enabled - Enable health check
  • --health-check-path <path> - Health check path
• coolify app delete <uuid> - Delete an application
  • -f, --force - Skip confirmation prompt
• coolify app start <uuid> - Start an application
• coolify app stop <uuid> - Stop an application
• coolify app restart <uuid> - Restart an application
• coolify app logs <uuid> - Get application logs
  • -f, --follow - Follow log output (like tail -f)
  • -n, --lines <n> - Number of log lines to retrieve (default: 100)
  • --show-timestamps - Include timestamps in logs
• coolify app move <uuid> --environment-uuid <uuid> - Move an application to another environment
• coolify app tag list|add|remove - Manage application tags
• Git-backed application create variants (public, github, and deploy-key) and app update support repeatable --compose-domain <service>=<url>[,<url>] flags for Docker Compose routing. On update, the supplied entries replace the existing mapping.
• All application create variants support --tag and --tags; create and update expose the full application settings surface.

Application Creation

• coolify app create public - Create an application from a public git repository
  • --server-uuid <uuid> - Server UUID (required)
  • --project-uuid <uuid> - Project UUID (required)
  • --environment-name <name> - Environment name (or use --environment-uuid <uuid>)
  • --git-repository <url> - Git repository URL (required)
  • --git-branch <branch> - Git branch (required)
  • --build-pack <pack> - Build pack: nixpacks, static, dockerfile, dockercompose (required)
  • --ports-exposes <ports> - Exposed ports, e.g., '3000' or '3000,8080' (required)
  • --domains <domains> - Domain(s) for the application
  • --instant-deploy - Deploy immediately after creation
  • More flags: --name, --description, --base-directory, --publish-directory, --build-command, --start-command, --install-command, --health-check-enabled, --health-check-path, --limits-memory, --limits-cpus, --ports-mappings, --git-commit-sha, --destination-uuid, --dockerfile-target-build
• coolify app create github - Create an application from a private repository using a GitHub App
  • Same flags as public, plus --github-app-uuid <uuid> (required)
  • --git-repository takes the owner/repo format
• coolify app create deploy-key - Create an application from a private repository using an SSH deploy key
  • Same flags as public, plus --private-key-uuid <uuid> (required)
  • --git-repository takes an SSH URL, e.g., git@github.com:owner/repo.git
• coolify app create dockerfile - Create an application from a custom Dockerfile
  • --dockerfile <content> - Dockerfile content (required)
  • --server-uuid <uuid> - Server UUID (required)
  • --project-uuid <uuid> - Project UUID (required)
  • --environment-name <name> - Environment name (or use --environment-uuid <uuid>)
• coolify app create dockerimage - Create an application from a pre-built Docker image
  • --docker-registry-image-name <image> - Docker image name from registry (required)
  • --docker-registry-image-tag <tag> - Docker image tag (defaults to latest)
  • --ports-exposes <ports> - Exposed ports (required)
  • --server-uuid <uuid> - Server UUID (required)
  • --project-uuid <uuid> - Project UUID (required)
  • --environment-name <name> - Environment name (or use --environment-uuid <uuid>)

Application Previews

• coolify app previews delete <app_uuid> <pr_id> - Delete a preview deployment
  • --force - Skip confirmation prompt

Application Storage

• coolify app storage list <app_uuid> - List all storages for an application
• coolify app storage create <app_uuid> - Create a storage for an application
  • --type <type> - Storage type: persistent or file (required)
  • --mount-path <path> - Mount path inside the container (required)
  • --name <name> - Volume name (persistent only)
  • --host-path <path> - Host path (persistent only)
  • --content <content> - File content (file only)
  • --is-directory - Whether this is a directory mount (file only)
  • --fs-path <path> - Host directory path (file only, required when --is-directory is set)
• coolify app storage update <app_uuid> - Update a storage for an application
  • --uuid <uuid> - Storage UUID (required, use storage list to find)
  • --type <type> - Storage type: persistent or file (required)
  • --is-preview-suffix-enabled - Enable preview suffix for this storage
  • Other flags same as create
• coolify app storage delete <app_uuid> <storage_uuid> - Delete a storage from an application

Application Environment Variables

• coolify app env list <app_uuid> - List all environment variables
• coolify app env get <app_uuid> <env_uuid_or_key> - Get a specific environment variable
• coolify app env create <app_uuid> - Create a new environment variable
  • --key <key> - Variable key (required)
  • --value <value> - Variable value (required)
  • --preview - Available in preview deployments
  • --build-time - Available at build time (default: true)
  • --runtime - Available at runtime (default: true)
  • --comment <comment> - Comment for the environment variable
  • --is-literal - Treat value as literal (don't interpolate variables)
  • --is-multiline - Value is multiline
• coolify app env update <app_uuid> <env_uuid_or_key> - Update an environment variable
  • --value <value> - Variable value (required)
  • --key <key> - New variable key (optional, for renaming)
  • --preview - Available in preview deployments
  • --build-time - Available at build time (default: true)
  • --runtime - Available at runtime (default: true)
  • --comment <comment> - Comment for the environment variable
  • --is-literal - Treat value as literal (don't interpolate variables)
  • --is-multiline - Value is multiline
• coolify app env delete <app_uuid> <env_uuid> - Delete an environment variable
  • --force - Skip confirmation prompt
• coolify app env sync <app_uuid> - Sync environment variables from a .env file
  • -f, --file <path> - Path to .env file (required)
  • --build-time - Make all variables available at build time (default: true)
  • --runtime - Make all variables available at runtime (default: true)
  • --preview - Make all variables available in preview deployments
  • --is-literal - Treat all values as literal (don't interpolate variables)
  • Behavior: Updates existing variables, creates missing ones. Does NOT delete variables not in the file.

Application Deployments

• coolify app deployments list <app-uuid> - List all deployments for an application
• coolify app deployments logs <app-uuid> [deployment-uuid] - Get deployment logs (formatted as human-readable text)
  • If only app-uuid is provided: retrieves logs from the latest/most recent deployment only
  • If deployment-uuid is also provided: retrieves logs for that specific deployment
  • -n, --lines <n> - Number of log lines to display (default: 0 = all lines)
  • -f, --follow - Follow log output in real-time (like tail -f)
  • --debuglogs - Show debug logs (includes hidden commands and internal operations)

Databases

• coolify database list - List all databases
• coolify database get <uuid> - Get database details
• coolify database create <type> - Create a new database
  • Supported types: postgresql, mysql, mariadb, mongodb, redis, keydb, clickhouse, dragonfly
  • --server-uuid <uuid> - Server UUID (required)
  • --project-uuid <uuid> - Project UUID (required)
  • --environment-name <name> - Environment name (required unless using --environment-uuid)
  • --environment-uuid <uuid> - Environment UUID (required unless using --environment-name)
  • --destination-uuid <uuid> - Destination UUID if server has multiple destinations
  • --name <name> - Database name
  • --description <description> - Database description
  • --image <image> - Docker image
  • --instant-deploy - Deploy immediately after creation
  • --is-public - Make database publicly accessible
  • --public-port <port> - Public port number
  • --limits-memory <size> - Memory limit (e.g., '512m', '2g')
  • --limits-cpus <cpus> - CPU limit (e.g., '0.5', '2')
  • Database-specific flags (postgres-user, mysql-root-password, etc.)
• coolify database update <uuid> - Update database configuration
• coolify database delete <uuid> - Delete a database
  • --delete-configurations - Delete configurations (default: true)
  • --delete-volumes - Delete volumes (default: true)
  • --docker-cleanup - Run docker cleanup (default: true)
  • --delete-connected-networks - Delete connected networks (default: true)
• coolify database start <uuid> - Start a database
• coolify database stop <uuid> - Stop a database
• coolify database restart <uuid> - Restart a database
• coolify database logs <uuid> - Get database logs
• coolify database move <uuid> --environment-uuid <uuid> - Move a database to another environment
• coolify database tag list|add|remove - Manage database tags
• Database creation supports repeatable --tag and comma-separated --tags.

Database Backups

• coolify database backup list <database_uuid> - List all backup configurations
• coolify database backup create <database_uuid> - Create a new backup configuration
  • --frequency <cron> - Backup frequency (cron expression)
  • --enabled - Enable backup schedule
  • --save-s3 - Save backups to S3
  • --s3-storage-uuid <uuid> - S3 storage UUID
  • --databases-to-backup <list> - Comma-separated list of databases to backup
  • --dump-all - Dump all databases
  • --retention-amount-locally <n> - Number of backups to retain locally
  • --retention-days-locally <n> - Days to retain backups locally
  • --retention-max-storage-locally <size> - Max storage for local backups (e.g., '1GB', '500MB')
  • --retention-amount-s3 <n> - Number of backups to retain in S3
  • --retention-days-s3 <n> - Days to retain backups in S3
  • --retention-max-storage-s3 <size> - Max storage for S3 backups (e.g., '1GB', '500MB')
  • --timeout <seconds> - Backup timeout in seconds
  • --disable-local-backup - Disable local backup storage
• coolify database backup update <database_uuid> <backup_uuid> - Update a backup configuration
• coolify database backup delete <database_uuid> <backup_uuid> - Delete a backup configuration
• coolify database backup trigger <database_uuid> <backup_uuid> - Trigger an immediate backup
• coolify database backup executions <database_uuid> <backup_uuid> - List backup executions
• coolify database backup delete-execution <database_uuid> <backup_uuid> <execution_uuid> - Delete a backup execution

Database Environment Variables

• coolify database env list <database_uuid> - List all environment variables
• coolify database env get <database_uuid> <env_uuid_or_key> - Get a specific environment variable
• coolify database env create <database_uuid> - Create a new environment variable
  • --key <key> - Variable key (required)
  • --value <value> - Variable value (required)
  • --comment <comment> - Comment for the environment variable
  • --is-literal - Treat value as literal (don't interpolate variables)
  • --is-multiline - Value is multiline
  • --is-shown-once - Only show value once
• coolify database env update <database_uuid> <env_uuid_or_key> - Update an environment variable
  • --value <value> - New variable value (required)
  • --key <key> - New variable key (optional, for renaming)
  • Other flags same as create
• coolify database env delete <database_uuid> <env_uuid> - Delete an environment variable
  • --force - Skip confirmation prompt
• coolify database env sync <database_uuid> - Sync environment variables from a .env file
  • -f, --file <path> - Path to .env file (required)
  • --is-literal - Treat all values as literal (don't interpolate variables)
  • Behavior: Updates existing variables, creates missing ones. Does NOT delete variables not in the file.

Database Storage

• coolify database storage list <db_uuid> - List all storages for a database
• coolify database storage create <db_uuid> - Create a storage for a database
  • Same flags as coolify app storage create
• coolify database storage update <db_uuid> - Update a storage for a database
  • Same flags as coolify app storage update
• coolify database storage delete <db_uuid> <storage_uuid> - Delete a storage from a database

Services

• coolify service list - List all services
• coolify service get <uuid> - Get service details
• coolify service create <type> - Create a new one-click service (e.g., wordpress-with-mysql, ghost, n8n)
  • --list-types - List all available service types
  • --server-uuid <uuid> - Server UUID (required)
  • --project-uuid <uuid> - Project UUID (required)
  • --environment-name <name> - Environment name (or use --environment-uuid <uuid>)
  • --name <name> - Service name
  • --description <description> - Service description
  • --docker-compose <content> - Custom Docker Compose content (for advanced customization)
  • --destination-uuid <uuid> - Destination UUID if server has multiple destinations
  • --instant-deploy - Deploy immediately after creation
• coolify service start <uuid> - Start a service
• coolify service stop <uuid> - Stop a service
• coolify service restart <uuid> - Restart a service
• coolify service delete <uuid> - Delete a service
• coolify service logs <uuid> --sub-service-name <name> - Get logs for a service application or database
• coolify service move <uuid> --environment-uuid <uuid> - Move a service to another environment
• coolify service tag list|add|remove - Manage service tags
• Service creation supports repeatable --tag and comma-separated --tags.

Service Applications

• coolify service application list <service_uuid> - List applications in a service
• coolify service application get <service_uuid> <application_uuid> - Get a service application
• coolify service application update <service_uuid> <application_uuid> - Update a service application
• coolify service application logs <service_uuid> <application_uuid> - Get application logs
• coolify service application start|restart|stop <service_uuid> <application_uuid> - Manage its lifecycle

Service Databases

• coolify service database list <service_uuid> - List databases in a service
• coolify service database get <service_uuid> <database_uuid> - Get a service database
• coolify service database update <service_uuid> <database_uuid> - Update metadata, image, log drain, or public access
• coolify service database logs <service_uuid> <database_uuid> - Get database logs
• coolify service database start|restart|stop <service_uuid> <database_uuid> - Manage its lifecycle

Service Environment Variables

• coolify service env list <service_uuid> - List all environment variables
• coolify service env get <service_uuid> <env_uuid_or_key> - Get a specific environment variable
• coolify service env create <service_uuid> - Create a new environment variable
  • Same flags as application environment variables, except --preview (not available for services)
• coolify service env update <service_uuid> <env_uuid_or_key> - Update an environment variable
  • --value <value> - Variable value (required)
  • --key <key> - New variable key (optional, for renaming)
  • --build-time - Available at build time (default: true)
  • --runtime - Available at runtime (default: true)
  • --comment <comment> - Comment for the environment variable
  • --is-literal - Treat value as literal (don't interpolate variables)
  • --is-multiline - Value is multiline
• coolify service env delete <service_uuid> <env_uuid> - Delete an environment variable
  • --force - Skip confirmation prompt
• coolify service env sync <service_uuid> - Sync environment variables from a .env file
  • -f, --file <path> - Path to .env file (required)
  • --build-time - Make all variables available at build time (default: true)
  • --runtime - Make all variables available at runtime (default: true)
  • --is-literal - Treat all values as literal (don't interpolate variables)
  • Behavior: Updates existing variables, creates missing ones. Does NOT delete variables not in the file.

Service Storage

• coolify service storage list <service_uuid> - List all storages for a service
• coolify service storage create <service_uuid> - Create a storage for a service
  • --resource-uuid <uuid> - UUID of the service application or database that owns the storage (required)
  • Other flags are the same as coolify app storage create
• coolify service storage update <service_uuid> - Update a storage for a service
  • Same flags as coolify app storage update
• coolify service storage delete <service_uuid> <storage_uuid> - Delete a storage from a service

Deployments

• coolify deploy uuid <uuid> - Deploy a resource by UUID
  • --force - Force deployment
  • --pull-request-id <id> - Pull request ID for preview deployments
  • --docker-tag <tag> - Docker image tag override for the deployment (requires Coolify 4.0.0-beta.471+)
• coolify deploy name <name> - Deploy a resource by name
  • --force - Force deployment
  • --pull-request-id <id> - Pull request ID for preview deployments
  • --docker-tag <tag> - Docker image tag override for the deployment (requires Coolify 4.0.0-beta.471+)
• coolify deploy batch <name1,name2,...> - Deploy multiple resources at once
  • --force - Force all deployments
  • --pull-request-id <id> - Pull request ID for preview deployments
  • --docker-tag <tag> - Docker image tag override for the deployment (requires Coolify 4.0.0-beta.471+)
• coolify deploy list - List all deployments
• coolify deploy get <uuid> - Get deployment details
• coolify deploy cancel <uuid> - Cancel a deployment
  • -f, --force - Skip confirmation prompt

GitHub Apps

• coolify github list - List all GitHub App integrations
• coolify github get <app_uuid> - Get GitHub App details
• coolify github create - Create a new GitHub App integration
  • --name <name> - GitHub App name (required)
  • --api-url <url> - GitHub API URL (optional; defaults to GitHub's public API)
  • --html-url <url> - GitHub HTML URL (required, e.g., https://github.com)
  • --app-id <id> - GitHub App ID (required)
  • --installation-id <id> - GitHub Installation ID (required)
  • --client-id <id> - GitHub OAuth Client ID (required)
  • --client-secret <secret> - GitHub OAuth Client Secret (required)
  • --private-key-uuid <uuid> - UUID of existing private key (required)
  • --organization <org> - GitHub organization
  • --custom-user <user> - Custom user for SSH (default: git)
  • --custom-port <port> - Custom port for SSH (default: 22)
  • --webhook-secret <secret> - GitHub Webhook Secret
  • --system-wide - Is this app system-wide (cloud only)
• coolify github update <app_uuid> - Update a GitHub App
• coolify github delete <app_uuid> - Delete a GitHub App
  • -f, --force - Skip confirmation prompt
• coolify github repos <app_uuid> - List repositories accessible by a GitHub App
• coolify github branches <app_uuid> <owner/repo> - List branches for a repository

Tags

• coolify tag list - List all tags for the current team

Destinations

• coolify destination list [--server <server_uuid>] - List Docker network destinations
• coolify destination get <uuid> - Get a destination
• coolify destination create --server <uuid> --network <name> [--type standalone|swarm] - Create a destination
• coolify destination delete <uuid> - Delete an unused destination

Cloud Provider Tokens

• coolify cloud-token list|get|create|update|delete|validate - Manage Hetzner, DigitalOcean, and Vultr API tokens
• Token values are redacted by default. --show-sensitive can reveal them only when the Coolify API token has sensitive-data permission.

Teams

• coolify team list - List all teams
• coolify team get <team_id> - Get team details
• coolify team current - Get current team
• coolify team members list [team_id] - List team members

Private Keys

Commands can use private-key, private-keys, key, or keys interchangeably.

• coolify private-key list - List all private keys
• coolify private-key add <key_name> <private_key_or_file> - Add a new private key
  • Pass the key content directly or a path to a key file: coolify private-key add mykey ~/.ssh/id_rsa
• coolify private-key remove <uuid> - Remove a private key

Coolify v5 Mesh (alpha)

These commands are an early preview of Coolify v5 fleet provisioning. Unlike the rest of the CLI they don't talk to the Coolify API: they connect to your servers over SSH to set up a WireGuard mesh with Podman and to manage cross-host container firewall rules.

• coolify init plan - Show WireGuard mesh changes without applying them
• coolify init bootstrap - First-time mesh install across all servers
• coolify init extend - Add new hosts to an existing mesh; existing hosts receive peer-refresh updates
• coolify init upgrade - Bump agent binary versions on every host
• coolify firewall containers - List containers on the Coolify mesh bridge across all servers
• coolify firewall list - List installed allow rules across all servers
• coolify firewall allow - Add an allow rule between containers
• coolify firewall revoke - Remove an allow rule

Both command trees require --servers and --ssh-key and take many more flags; run coolify init --help / coolify firewall --help or see llms-full.txt for the full reference.

Global Flags

All commands support these global flags:

• --context <name> - Use a specific context instead of default
• --token <token> - Override the authentication token
• --format <format> - Output format: table (default), json, or pretty
• -s, --show-sensitive - Show sensitive information (tokens, IPs, etc.)
• --debug - Enable debug mode

Examples

Multi-Environment Workflows

# Add multiple contexts
coolify context add prod https://prod.coolify.io <prod-token>
coolify context add staging https://staging.coolify.io <staging-token>
coolify context add dev https://dev.coolify.io <dev-token>

# Set default
coolify context use prod

# Use different contexts
coolify --context=staging servers list
coolify --context=prod deploy name api
coolify --context=dev resources list

# Default context (prod in this case)
coolify servers list

Application Management

# List all applications
coolify app list

# Get application details
coolify app get <uuid>

# Create an application from a public git repository
coolify app create public --server-uuid <uuid> --project-uuid <uuid> --environment-name production \
  --git-repository "https://github.com/user/repo" --git-branch main --build-pack nixpacks --ports-exposes 3000

# Create an application from a pre-built Docker image
coolify app create dockerimage --server-uuid <uuid> --project-uuid <uuid> --environment-name production \
  --docker-registry-image-name "nginx:latest" --ports-exposes 80

# Manage application lifecycle
coolify app start <uuid>
coolify app stop <uuid>
coolify app restart <uuid>

# View application logs
coolify app logs <uuid>

# Environment variables
coolify app env list <uuid>
coolify app env create <uuid> --key API_KEY --value secret123

# Sync from .env file (updates existing, creates new, keeps others unchanged)
coolify app env sync <uuid> --file .env
coolify app env sync <uuid> --file .env.production --build-time --preview

Database Management

# List databases
coolify database list

# Create a PostgreSQL database
coolify database create postgresql \
  --server-uuid <server-uuid> \
  --project-uuid <project-uuid> \
  --name mydb \
  --instant-deploy

# Manage database lifecycle
coolify database start <uuid>
coolify database stop <uuid>
coolify database restart <uuid>

# Backup management
coolify database backup list <database-uuid>
coolify database backup create <database-uuid> \
  --frequency "0 2 * * *" \
  --enabled \
  --save-s3 \
  --retention-days-locally 7
coolify database backup trigger <database-uuid> <backup-uuid>

Service Management

# List services
coolify service list

# Get service details
coolify service get <uuid>

# See all available one-click service types
coolify service create --list-types

# Create a one-click service
coolify service create wordpress-with-mysql --server-uuid=<uuid> --project-uuid=<uuid> --environment-name=production

# Manage services
coolify service start <uuid>
coolify service restart <uuid>

# Environment variables (same as applications)
coolify service env sync <uuid> --file .env

Deploy Workflows

# Deploy single app by name (easier than UUID)
coolify deploy name my-application

# Deploy multiple apps at once
coolify deploy batch api,worker,frontend

# Force deploy with specific context
coolify --context=prod deploy batch api,worker --force

# Deploy a preview with an explicit docker tag
coolify deploy uuid u5ualfp30j27qtfpgcen8p03 --pull-request-id 2345 --docker-tag 1.28.3

# Traditional UUID deployment still works
coolify deploy uuid abc123-def456-...

# Monitor deployments
coolify deploy list
coolify deploy get <deployment-uuid>

# Cancel a deployment
coolify deploy cancel <deployment-uuid>

GitHub Apps Integration

# List GitHub Apps
coolify github list

# Create a GitHub App integration
coolify github create \
  --name "My GitHub App" \
  --api-url "https://api.github.com" \
  --html-url "https://github.com" \
  --app-id 123456 \
  --installation-id 789012 \
  --client-id "Iv1.abc123" \
  --client-secret "secret" \
  --private-key-uuid <key-uuid>

# List repositories accessible by the app
coolify github repos <app-uuid>

# List branches for a repository
coolify github branches <app-uuid> owner/repo

# Delete a GitHub App
coolify github delete <app-uuid>

Team Management

# List teams
coolify team list

# Get current team
coolify team current

# List team members
coolify team members list

Server Management

# List servers in production
coolify --context=prod server list

# Add a server with validation
coolify server add myserver 192.168.1.100 <key-uuid> --validate

# Get server details with resources
coolify server get <uuid> --resources

Output Formats

The CLI supports three output formats:

# Table format (default, human-readable)
coolify server list

# JSON format (for scripts)
coolify server list --format=json

# Pretty JSON (for debugging)
coolify server list --format=pretty

Architecture

This CLI follows a clean architecture with:

• Service Layer: Business logic and API interactions
• Output Layer: Consistent formatting across all commands
• Config Layer: Multi-context configuration management
• Models Layer: Type-safe data structures

Development

# Build
go build -o coolify ./coolify

# Run tests
go test ./...

# Run with coverage
go test -cover ./...

# Install locally
go install ./coolify

Contributing

Contributions are welcome!

License

MIT