gem-hunter

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

brew install coollabsio/coolify-cli/coolify-cli

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

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.

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

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

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.

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

go run ./coolify docs llms

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

• coolify update - Update the CLI to the latest version

• coolify version - Show the current CLI version

• coolify config - Show configuration file location

• coolify settings email get - Get instance-wide SMTP and Resend settings
• coolify settings email update --json '<settings>' - Update instance email settings using a root-team admin/owner token with write:sensitive
  • Example: coolify settings email update --json '{"smtp_ehlo_domain":"coolify.example.com"}'
  • Set the EHLO domain to null to use the system default

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

• 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 (name, URL, default; the API token is never shown)
• 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

Commands can use server or servers interchangeably.

• coolify server list - List all servers
• coolify server get <uuid> - Get a server by UUID
  • --resources - List the resources deployed on the server (uuid, name, type, status) instead of the server details
• 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
  • --server-role <deployment|build|both> - Server role (API default: both). deployment requires another usable build server in the team
• coolify server update <uuid> - Update a server (only the given flags are changed)
  • --server-role <deployment|build|both> - Change the server role
  • --is-build-server - Deprecated: maps to --server-role build (true) or --server-role both (false); cannot be combined with --server-role
  • Run coolify server update --help for the remaining flags
• 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|hostinger - List provider options and provision a server
• coolify server hostinger data-centers|catalog|templates|ssh-keys|post-install-scripts <cloud_token_uuid> - List Hostinger options (catalog shows one row per plan and billing period; its item_id is used for --item-id)
• coolify server hostinger create - Purchase a Hostinger VPS and add it as a server. This is a paid, recurring (monthly/yearly) purchase and asks for confirmation.
  • --cloud-token <uuid>, --item-id <price_id>, --data-center-id <id>, --template-id <id>, --private-key <uuid> - Required
  • --name, --enable-backups (default: false; backups cost extra), --ssh-key-ids, --post-install-script-id, --validate - Optional
  • -f, --force - Skip the purchase confirmation prompt
• coolify server registry list <server_uuid> - List the Docker registries a server is logged in to and which resources use them (requires a token with read:sensitive; usernames are hidden in table output unless -s is given)
• coolify server registry login <server_uuid> [<server_uuid>...] - Run docker login on one or more servers
  • --registry <host> - Registry host, optionally with a port, e.g. ghcr.io, registry.example.com:5000, docker.io (required)
  • -u, --username <username> - Registry username (required)
  • --password-stdin - Read the password or access token from stdin. Without it, the password is prompted without echo in a terminal. There is no flag for the password itself
  • Example: echo "$GHCR_TOKEN" | coolify server registry login <server_uuid> --registry ghcr.io -u octocat --password-stdin
• coolify server registry check <server_uuid> <registry> - Check that the saved login still works
• coolify server registry logout <server_uuid> <registry> - Run docker logout on the server
  • -f, --force - Skip confirmation prompt

• 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
• coolify projects environments get <project_uuid> <environment_name_or_uuid> - Get an environment and its applications, databases and services (alias: env)

• coolify resources list - List all resources

• 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
  • --service <name> - Docker Compose service name (select one container in multi-service compose apps)
• coolify app move <uuid> --environment-uuid <uuid> - Move an application to another environment
• coolify app tag list|add|remove - Manage application tags
• coolify app secret-manager set <app_uuid> - Set the external secret manager an application reads secrets from
  • --integration-token <uuid> - Secret manager integration token UUID (required, see Secret Manager Integration Tokens)
  • --settings <json> - Provider settings as a JSON object: Doppler {"project":"...","config":"..."} (service account tokens), Infisical {"project_id":"...","environment":"...","secret_path":"/"}, Vault {"mount":"...","path":"..."}
• 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.

• 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>)

• coolify app previews list <app_uuid> - List preview deployments
• coolify app previews get <app_uuid> <pr_id> - Get a preview deployment
• coolify app previews create <app_uuid> <pr_id> - Open a preview deployment and queue its deployment (redeploys an existing preview)
  • --git-type <type> - Git provider of the pull request: github, gitlab, gitea, or bitbucket (required unless the application uses a GitHub App or GitLab App source)
  • --commit <sha> - Commit SHA to deploy (required for Bitbucket)
  • --docker-tag <tag> - Docker image tag (Docker Image applications; required for a new preview)
  • --url <url> - Pull request URL
  • --force - Rebuild without cache
  • --no-deploy - Only create the preview, do not queue a deployment
• coolify app previews update <app_uuid> <pr_id> - Replace the domains of a preview deployment
  • --domains <domains> - Domains (comma-separated)
  • --compose-domain <service>=<url> - Docker Compose service domain (repeatable)
  • --force-domain-override - Save the domains even when another resource uses them
• coolify app previews logs <app_uuid> <pr_id> - Get runtime logs of a preview deployment
  • --lines, -n <n> - Number of log lines to retrieve (default: 100, -1 for all)
  • --follow, -f - Follow log output (like tail -f)
  • --show-timestamps - Show timestamps in log output
  • --service <name> - Docker Compose service name (selects one container in multi-service apps)
• coolify app previews delete <app_uuid> <pr_id> - Delete a preview deployment
  • --force - Skip confirmation prompt

• 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

• 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.

• 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)

• 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, sqlite
  • --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.)
  • --sqlite-databases <files> - SQLite: comma-separated database file names (e.g. app.db,cache.db). SQLite does not support --is-public/--public-port.
• coolify database update <uuid> - Update database configuration
  • --sqlite-databases <files> - SQLite: comma-separated database file names
• 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.

• 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

• coolify database import start <database_uuid> - Import a backup into the database (exactly one source):
  • --file <path> - Upload a local backup file (max 10 GiB, uploaded in 10 MB chunks), then import it
  • --upload-id <id> - Import a file previously uploaded with import upload
  • --s3-storage-uuid <uuid> --s3-path <path> - Import a backup from S3 storage
  • --server-path <path> - Import a file on the database's server (token needs deploy permission)
  • --dump-all - The backup contains all databases
  • --replace-existing - PostgreSQL: drop matching objects before restoring a single-database archive
  • --keep-owners - PostgreSQL: restore owners and privileges from a single-database archive
  • --restore-mysql-users - MySQL/MariaDB all-databases backups: also restore users, passwords and privileges
  • --sqlite-database <file> - SQLite: database file to restore into
  • --wait - Wait until the import finishes (non-zero exit on failure); --poll-interval <duration> (default 3s)
• coolify database import upload <database_uuid> <file> - Upload a backup file and print its upload ID
• coolify database import status <database_uuid> <activity_id> - Show import status and output (--wait to follow)

• 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.

• 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

• 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.

• 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
  • --lines, -n <n> - Number of log lines to retrieve (default: 100)
• coolify service application start|restart|stop <service_uuid> <application_uuid> - Manage its lifecycle

• 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
• coolify service database import start <service_uuid> <database_uuid> - Import a backup (same source/option flags as coolify database import start)
• coolify service database import upload <service_uuid> <database_uuid> <file> - Upload a backup file and print its upload ID
• coolify service database import status <service_uuid> <database_uuid> <activity_id> - Show import status (--wait to follow)

• 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.

• 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

• 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+)
• co