Coolify Manager

Coolify Manager

Skill for managing Coolify deployments through CLI (v1.4.0) and direct API access. Covers diagnosing issues, fixing WordPress problems, managing containers, creating resources, and performing deployments.

Prerequisites

1. Coolify instance access (self-hosted or cloud) 2. API token from Coolify dashboard at /security/api-tokens 3. Coolify CLI installed (see scripts/install_coolify_cli.sh)

Setup

# Install CLI
bash scripts/install_coolify_cli.sh

# Add context
coolify context add <name> <url> <token>

# Verify connection
coolify context verify

# Quick health check
bash scripts/check_health.sh

For full CLI reference including all flags and subcommands, load references/cli_commands.md.

Diagnosing Issues — Decision Tree

When a user reports a problem, follow this tree:

1. Service Availability

Site is down?
├── Check status: coolify resource list
├── Get details: coolify service get <uuid>
├── Check logs:  coolify app logs <uuid> --follow
│   └── Logs point to config issue? → Check env vars, restart
│   └── Logs point to crash? → Check app code, memory limits
└── Restart:     coolify service restart <uuid>

2. WordPress-Specific

WordPress issue?
├── 500 error after .htaccess change → Load references/wordpress_fixes.md
├── REST API warnings in Site Health → Likely false positive, test with curl
├── PHP limits (upload, memory, etc.) → Fix via .htaccess php_value directives
├── SSL certificate issues → Check with openssl, regenerate in dashboard
└── Access container: Coolify dashboard → Terminal → select "wordpress" container

For detailed WordPress troubleshooting steps, load references/wordpress_fixes.md.

3. Deployment Issues

Deploy failed?
├── Check deployments: coolify app deployments list <app-uuid>
├── Get deploy logs:   coolify app deployments logs <app-uuid> --follow
├── Cancel stuck deploy: coolify deploy cancel <deploy-uuid>
├── Fix issue (env vars, config, code)
└── Redeploy: coolify deploy uuid <app-uuid>
    Or by name: coolify deploy name <resource-name>
    Or batch:   coolify deploy batch <name1,name2,...>

4. Configuration/Environment

Need config changes?
├── App env vars:     coolify app env list <uuid>
│   ├── Create:       coolify app env create <uuid> --key K --value V
│   ├── Sync .env:    coolify app env sync <uuid> --file .env.production
│   └── Delete:       coolify app env delete <uuid> <env-uuid>
├── Service env vars: coolify service env list <uuid>
│   └── Same subcommands: create, get, update, delete, sync
└── After changes:    coolify app restart <uuid>

Creating Resources

Applications

5 source types available:

# From public repo
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

# From Docker image
coolify app create dockerimage --server-uuid <uuid> --project-uuid <uuid> \
  --environment-name production --docker-registry-image-name "nginx:latest" \
  --ports-exposes 80 --instant-deploy

Other source types: github, deploy-key, dockerfile. See references/cli_commands.md for full flags.

One-Click Services

# List available service types
coolify service create --list-types

# Create WordPress
coolify service create wordpress-with-mysql \
  --server-uuid <uuid> --project-uuid <uuid> \
  --environment-name production --instant-deploy

Popular types: wordpress-with-mysql, ghost, n8n, supabase, pocketbase, uptime-kuma, grafana, nextcloud, gitea, minio, metabase.

Databases

Supported: postgresql, mysql, mariadb, mongodb, redis, keydb, clickhouse, dragonfly.

coolify database create postgresql --server-uuid <uuid> --project-uuid <uuid> \
  --environment-name production --postgres-db mydb --postgres-user admin \
  --postgres-password secret --instant-deploy

Backup Management

Database backups support scheduled cron jobs, local and S3 retention policies:

# Create scheduled backup (daily at midnight)
coolify database backup create <db-uuid> --frequency "0 0 * * *" --enabled \
  --save-s3 --s3-storage-uuid <s3-uuid> --retention-amount-s3 30

# Trigger immediate backup
coolify database backup trigger <db-uuid> <backup-uuid>

# List backup executions
coolify database backup executions <db-uuid> <backup-uuid>

Key Concepts

• Resource types: application, service (one-click), database
• UUIDs: every resource has a unique UUID — use coolify resource list to find them
• Contexts: named connections to Coolify instances (url + token). Switch with coolify context use <name>
• Build packs: nixpacks, static, dockerfile, dockercompose
• Deploy methods: by UUID, by name, or batch (multiple at once)

CLI Quick Reference

For the complete CLI reference with all commands, flags, and examples, load references/cli_commands.md.

References

• `references/cli_commands.md` — Complete CLI v1.4.0 command reference with all flags, aliases, and examples. Load when the user needs specific command syntax.
• `references/api_endpoints.md` — REST API endpoints for direct HTTP calls. Load when CLI doesn't support an operation or the user prefers API access.
• `references/wordpress_fixes.md` — WordPress-specific troubleshooting (.htaccess, PHP config, REST API, SSL). Load for any WordPress issue on Coolify.

Coolify API Endpoints Reference

Base URL: https://your-coolify-instance.com/api/v1

All endpoints require bearer token authentication:

-H "Authorization: Bearer YOUR_API_TOKEN"

Table of Contents

1. Resources 2. Applications 3. Application Environment Variables 4. Services 5. Service Environment Variables 6. Databases 7. Database Backups 8. Deployments 9. Servers 10. Projects 11. Teams 12. Private Keys

---

Resources

List All Resources

GET /resources

Returns all resources (applications, services, databases) with UUIDs, names, types, and status.

---

Applications

CRUD

GET    /applications                    # List all
GET    /applications/{uuid}             # Get details
POST   /applications                    # Create (see CLI for easier creation)
PATCH  /applications/{uuid}             # Update configuration
DELETE /applications/{uuid}             # Delete

Lifecycle

POST /applications/{uuid}/start
POST /applications/{uuid}/stop
POST /applications/{uuid}/restart

Logs

GET /applications/{uuid}/logs?lines=200

Query parameters: lines (default: 100)

---

Application Environment Variables

GET    /applications/{uuid}/envs                 # List all env vars
POST   /applications/{uuid}/envs                 # Create env var
PATCH  /applications/{uuid}/envs                 # Update env var (bulk)
PATCH  /applications/{uuid}/envs/{env_uuid}      # Update specific env var
DELETE /applications/{uuid}/envs/{env_uuid}      # Delete env var

---

Services

CRUD

GET    /services                        # List all
GET    /services/{uuid}                 # Get details (includes docker-compose, apps, DBs)
POST   /services                        # Create one-click service
DELETE /services/{uuid}                 # Delete

Lifecycle

POST /services/{uuid}/start
POST /services/{uuid}/stop
POST /services/{uuid}/restart

---

Service Environment Variables

GET    /services/{uuid}/envs
POST   /services/{uuid}/envs
PATCH  /services/{uuid}/envs/{env_uuid}
DELETE /services/{uuid}/envs/{env_uuid}

---

Databases

CRUD

GET    /databases                        # List all
GET    /databases/{uuid}                 # Get details
POST   /databases                        # Create
PATCH  /databases/{uuid}                 # Update
DELETE /databases/{uuid}                 # Delete

Lifecycle

POST /databases/{uuid}/start
POST /databases/{uuid}/stop
POST /databases/{uuid}/restart

---

Database Backups

GET    /databases/{uuid}/backups                              # List backup configs
POST   /databases/{uuid}/backups                              # Create backup config
GET    /databases/{uuid}/backups/{backup_uuid}                # Get backup config
PATCH  /databases/{uuid}/backups/{backup_uuid}                # Update backup config
DELETE /databases/{uuid}/backups/{backup_uuid}                # Delete backup config
GET    /databases/{uuid}/backups/{backup_uuid}/executions     # List executions
POST   /databases/{uuid}/backups/{backup_uuid}/trigger        # Trigger immediate backup
DELETE /databases/{uuid}/backups/{backup_uuid}/executions/{exec_uuid}  # Delete execution

---

Deployments

Deploy

POST /deploy

Request body:

{"uuid": "resource-uuid"}

Status

GET /deployments              # List all running
GET /deployments/{uuid}       # Get deployment details

---

Servers

GET    /servers                         # List all
GET    /servers/{uuid}                  # Get details
POST   /servers                         # Add server
POST   /servers/{uuid}/validate         # Validate connection
GET    /servers/{uuid}/domains          # Get server domains
DELETE /servers/{uuid}                  # Remove server

---

Projects

GET    /projects                        # List all
GET    /projects/{uuid}                 # Get details
POST   /projects                        # Create project

---

Teams

GET /teams                              # List all teams
GET /teams/{id}                         # Get team details
GET /teams/{id}/members                 # List team members
GET /teams/current                      # Current authenticated team
GET /teams/current/members              # Current team members

---

Private Keys

GET    /security/keys                   # List all
GET    /security/keys/{uuid}            # Get key details
POST   /security/keys                   # Add key
DELETE /security/keys/{uuid}            # Remove key

---

Common Response Codes

Rate Limiting

Check response headers:

• X-RateLimit-Limit
• X-RateLimit-Remaining
• X-RateLimit-Reset

Example: Filtering with jq

# Get all unhealthy services
curl -s -H "Authorization: Bearer $TOKEN" \
  https://instance.com/api/v1/resources \
  | jq '.[] | select(.status | contains("unhealthy"))'

# Get service apps and their status
curl -s -H "Authorization: Bearer $TOKEN" \
  https://instance.com/api/v1/services/SERVICE_UUID \
  | jq '.applications[] | {name, status}'

Coolify CLI Commands Reference

Version: 1.4.0

Table of Contents

1. Global Flags 2. Context Management 3. Applications 4. Application Environment Variables 5. Application Deployments 6. Services 7. Service Environment Variables 8. Databases 9. Database Backups 10. Deploy Commands 11. Servers 12. Projects 13. Teams 14. GitHub Integrations 15. Private Keys 16. Resources 17. Configuration & Updates

---

Global Flags

Available with all commands:

---

Context Management

Manage connections to Coolify instances. Aliases: none.

Add Context

coolify context add <name> <url> <token>
# Flags: -d/--default (set as default), -f/--force (overwrite existing)

List / Get / Use

coolify context list
coolify context get <name>
coolify context use <name>           # Switch default context
coolify context set-default <name>   # Same as 'use'

Update / Set Token

coolify context update <name> --name <new> --url <new> --token <new>
coolify context set-token <name> <token>

Verify / Version / Delete

coolify context verify      # Test connection and auth
coolify context version     # Get Coolify server version
coolify context delete <name>

---

Applications

Aliases: app, apps, application, applications

List / Get

coolify app list
coolify app get <uuid>

Create Application

5 source types: public, github, deploy-key, dockerfile, dockerimage

Common required flags: --server-uuid, --project-uuid, --environment-name (or --environment-uuid)

# From public git repo
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

# From GitHub App (private repo)
coolify app create github \
  --server-uuid <uuid> --project-uuid <uuid> --environment-name production \
  --github-app-uuid <uuid> --git-repository "owner/repo" --git-branch main \
  --build-pack nixpacks --ports-exposes 3000

# From SSH deploy key (private repo)
coolify app create deploy-key \
  --server-uuid <uuid> --project-uuid <uuid> --environment-name production \
  --private-key-uuid <uuid> --git-repository "git@github.com:owner/repo.git" \
  --git-branch main --build-pack nixpacks --ports-exposes 3000

# From Dockerfile content
coolify app create dockerfile \
  --server-uuid <uuid> --project-uuid <uuid> --environment-name production \
  --dockerfile "$(cat Dockerfile)" --ports-exposes 3000

# From Docker image
coolify app create dockerimage \
  --server-uuid <uuid> --project-uuid <uuid> --environment-name production \
  --docker-registry-image-name "nginx:latest" --ports-exposes 80

Optional flags (for git-based sources): --name, --description, --domains, --base-directory, --build-command, --install-command, --start-command, --publish-directory, --git-commit-sha, --health-check-enabled, --health-check-path, --limits-cpus, --limits-memory, --ports-mappings, --destination-uuid, --instant-deploy

Build packs: nixpacks, static, dockerfile, dockercompose

Update Application

coolify app update <uuid> --name "New Name" --domains "app.example.com" --git-branch develop

Updateable fields: --name, --description, --domains, --git-branch, --git-repository, --base-directory, --build-command, --install-command, --start-command, --publish-directory, --dockerfile, --docker-image, --docker-tag, --ports-exposes, --ports-mappings, --health-check-enabled, --health-check-path

Lifecycle Control

coolify app start <uuid>     # Aliases: start, deploy. Flags: --force, --instant-deploy
coolify app stop <uuid>
coolify app restart <uuid>
coolify app delete <uuid>    # Flag: -f/--force (skip confirmation)

Application Logs

coolify app logs <uuid>
coolify app logs <uuid> --lines 500    # Default: 100
coolify app logs <uuid> --follow       # Stream logs (like tail -f)

---

Application Environment Variables

Aliases: env, envs, environment

List / Get

coolify app env list <app-uuid>
coolify app env list <app-uuid> --preview   # Show preview env vars
coolify app env list <app-uuid> --all       # Show all (regular + preview)
coolify app env get <app-uuid> <env-uuid-or-key>

Create / Update / Delete

coolify app env create <app-uuid> --key DATABASE_URL --value "postgres://..."
# Flags: --build-time (default true), --runtime (default true),
#         --is-literal, --is-multiline, --preview

coolify app env update <app-uuid> <env-uuid> --value "new-value"
# Same flags as create plus --key for renaming

coolify app env delete <app-uuid> <env-uuid>   # Flag: --force

Sync from .env File

coolify app env sync <app-uuid> --file .env.production
# Intelligently creates new vars and updates existing ones
# Flags: --build-time, --runtime, --is-literal, --preview

---

Application Deployments

Per-application deployment history and logs.

coolify app deployments list <app-uuid>
coolify app deployments logs <app-uuid>                      # Latest deployment
coolify app deployments logs <app-uuid> <deployment-uuid>    # Specific deployment
# Flags: --follow (-f), --lines (-n), --debuglogs

---

Services

One-click services (WordPress, Redis, Ghost, etc.). Aliases: service, services, svc

List / Get

coolify service list
coolify service get <uuid>

Create Service

# List available types
coolify service create --list-types

# Create with flags
coolify service create <type> \
  --server-uuid <uuid> --project-uuid <uuid> \
  --environment-name production --name "My Service" --instant-deploy

Popular types: wordpress-with-mysql, wordpress-with-mariadb, wordpress-without-database, ghost, plausible, umami, uptime-kuma, n8n, n8n-with-postgresql, nextcloud, gitea, minio, grafana, metabase, nocodb, supabase, pocketbase, appwrite

Optional flags: --name, --description, --destination-uuid, --docker-compose, --instant-deploy, --environment-uuid

Lifecycle Control

coolify service start <uuid>
coolify service stop <uuid>
coolify service restart <uuid>
coolify service delete <uuid>
# Delete flags: -f/--force, --delete-configurations (default true),
#   --delete-volumes (default true), --delete-connected-networks (default true),
#   --docker-cleanup (default true)

---

Service Environment Variables

Same structure as app env vars.

coolify service env list <service-uuid>
coolify service env get <service-uuid> <env-uuid-or-key>
coolify service env create <service-uuid> --key K --value V
coolify service env update <service-uuid> <env-uuid> --value "new"
coolify service env delete <service-uuid> <env-uuid>   # Flag: --force
coolify service env sync <service-uuid> --file .env
# Flags: --build-time, --runtime, --is-literal, --is-multiline

---

Databases

Aliases: database, databases, db, dbs

Supported types: postgresql, mysql, mariadb, mongodb, redis, keydb, clickhouse, dragonfly

List / Get

coolify database list
coolify database get <uuid>

Create Database

coolify database create <type> --server-uuid <uuid> --project-uuid <uuid> \
  --environment-name production --name "My DB" --instant-deploy

Type-specific flags:

• PostgreSQL: --postgres-db, --postgres-user, --postgres-password
• MySQL: --mysql-database, --mysql-user, --mysql-password, --mysql-root-password
• MariaDB: --mariadb-database, --mariadb-user, --mariadb-password, --mariadb-root-password
• MongoDB: --mongo-database, --mongo-root-username, --mongo-root-password
• Redis: --redis-password
• KeyDB: --keydb-password
• Clickhouse: --clickhouse-admin-user, --clickhouse-admin-password
• Dragonfly: --dragonfly-password

Common optional flags: --name, --description, --image, --is-public, --public-port, --limits-cpus, --limits-memory, --destination-uuid

Update Database

coolify database update <uuid> --name "New Name" --limits-memory "2g"
# Fields: --name, --description, --image, --is-public, --public-port,
#          --limits-cpus, --limits-memory

Lifecycle Control

coolify database start <uuid>
coolify database stop <uuid>
coolify database restart <uuid>
coolify database delete <uuid>
# Delete flags: --delete-configurations (default true), --delete-volumes (default true),
#   --delete-connected-networks (default true), --docker-cleanup (default true)

---

Database Backups

Full backup management with scheduling, retention, and S3 support.

List / View

coolify database backup list <db-uuid>
coolify database backup executions <db-uuid> <backup-uuid>

Create Scheduled Backup

coolify database backup create <db-uuid> \
  --frequency "0 0 * * *" --enabled \
  --save-s3 --s3-storage-uuid <uuid> \
  --retention-amount-s3 30 --retention-days-s3 90

Flags: --frequency (cron expr), --enabled, --databases-to-backup, --dump-all, --save-s3, --s3-storage-uuid, --disable-local-backup, --retention-amount-locally, --retention-amount-s3, --retention-days-locally, --retention-days-s3, --retention-max-storage-locally, --retention-max-storage-s3, --timeout

Trigger / Update / Delete

coolify database backup trigger <db-uuid> <backup-uuid>
coolify database backup update <db-uuid> <backup-uuid> --frequency "0 */6 * * *"
coolify database backup delete <db-uuid> <backup-uuid>   # Flag: --delete-s3
coolify database backup delete-execution <db-uuid> <backup-uuid> <exec-uuid>  # Flag: --delete-s3

---

Deploy Commands

Multiple ways to deploy resources.

# Deploy by UUID
coolify deploy uuid <uuid>           # Flag: --force

# Deploy by resource name
coolify deploy name <resource-name>  # Flag: --force

# Deploy multiple at once
coolify deploy batch <name1,name2,...>  # Flag: --force

# Cancel in-progress deployment
coolify deploy cancel <deploy-uuid>  # Flag: -f/--force

# List running deployments
coolify deploy list

# Get deployment details
coolify deploy get <deploy-uuid>

---

Servers

Aliases: server, servers

coolify server list
coolify server get <uuid>              # Flag: --resources (include resources)
coolify server add <name> <ip> <key-uuid>  # Flags: -p/--port (default 22), -u/--user (default root), --validate
coolify server validate <uuid>
coolify server domains <uuid>          # Alias: domain
coolify server remove <uuid>

---

Projects

Aliases: project, projects

coolify project list
coolify project get <uuid>
coolify project create --name "My Project" --description "..."

---

Teams

Aliases: teams, team

coolify teams list
coolify teams get <team-id>
coolify teams current                        # Current authenticated team
coolify teams members list [team-id]         # Optional team-id, defaults to current

Members alias: member

---

GitHub Integrations

Aliases: github, gh, github-app, github-apps

coolify github list
coolify github get <app-uuid>
coolify github repos <app-uuid>
coolify github branches <app-uuid> <owner/repo>
coolify github delete <app-uuid>   # Flag: -f/--force

Create GitHub App

coolify github create \
  --name "My App" --api-url "https://api.github.com" --html-url "https://github.com" \
  --app-id 123456 --installation-id 789012 \
  --client-id "Iv1.abc" --client-secret "secret" \
  --private-key-uuid <uuid>
# Optional: --organization, --custom-port, --custom-user, --webhook-secret, --system-wide

Update GitHub App

coolify github update <app-uuid> --name "New Name" --webhook-secret "new-secret"
# Same flags as create (all optional for update)

---

Private Keys

Aliases: private-key, private-keys, key, keys

coolify private-key list
coolify private-key add <name> <key-or-file-path>
coolify private-key remove <uuid>

---

Resources

Aliases: resource, resources

coolify resource list           # All resources (apps, services, databases) with UUID, name, type, status
coolify resource list --format json | jq '.[] | select(.status | contains("unhealthy"))'

---

Configuration & Updates

coolify config      # Show config file location (~/.config/coolify/config.json)
coolify version     # Current CLI version
coolify update      # Check for and install updates

---

Output Formats

coolify resource list                  # Table (default, human-readable)
coolify resource list --format json    # JSON (machine-readable, pipe to jq)
coolify resource list --format pretty  # Pretty JSON (indented)

Tips

1. Filter with jq: coolify resource list --format json | jq '.[] | select(.status=="running")' 2. Show secrets: coolify server list -s (shows IPs, passwords) 3. Skip confirmations: coolify app delete <uuid> --force 4. Override token: coolify --token <token> resource list (useful for scripts) 5. Debug mode: coolify --debug context verify 6. Switch contexts: coolify --context staging deploy uuid <uuid> (one-off context switch)

WordPress on Coolify: Common Issues and Fixes

Table of Contents

1. Accessing WordPress Container 2. .htaccess Issues 3. PHP Configuration 4. REST API Issues 5. SSL Certificate Issues

---

Accessing WordPress Container

Via Coolify Web Terminal

1. Navigate to your Coolify dashboard 2. Go to your WordPress service 3. Click Terminal in the sidebar 4. Select the wordpress container 5. You're now in the container shell

Via Docker (if you have SSH access)

docker exec -it CONTAINER_NAME bash

WordPress Files Location

/var/www/html/

---

.htaccess Issues

Symptom: Site is down after editing .htaccess

Common causes:

• Syntax errors in PHP directives
• Invalid Apache directives
• Malformed rewrite rules

Quick Fix: View and Edit .htaccess

cd /var/www/html
cat .htaccess

Remove Last Line (if it's problematic)

sed -i '$d' /var/www/html/.htaccess

Restore Default WordPress .htaccess

cat > /var/www/html/.htaccess << 'EOF'
# BEGIN WordPress
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
RewriteBase /
RewriteRule ^index\.php$ - [L]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /index.php [L]
</IfModule>
# END WordPress
EOF

---

PHP Configuration

Increasing PHP Limits via .htaccess

Correct syntax (note: space between value and number, no = sign):

php_value upload_max_filesize 64M
php_value post_max_size 128M
php_value memory_limit 256M
php_value max_execution_time 300
php_value max_input_time 300
php_value max_input_vars 3000

Incorrect syntax (will break Apache):

php_value max_input_vars = 3000#   ❌ Don't use = or trailing #

Add PHP Settings to .htaccess

echo "php_value max_input_vars 3000" >> /var/www/html/.htaccess

Verify Settings

tail -10 /var/www/html/.htaccess

---

REST API Issues

Symptom: REST API appears unavailable in Site Health

Test if REST API is actually working:

curl https://your-site.com/?rest_route=/
curl https://your-site.com/wp-json/

If JSON data returns, the REST API is working - it's a false positive.

Common Causes of False Positives

1. Site Health loopback test blocked (the test itself fails, but API works) 2. Authentication issues - loopback endpoint requires auth 3. Security plugins blocking self-requests

Check .htaccess for HTTP_AUTHORIZATION

Ensure this line exists in the WordPress section:

RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]

Real API Issues

If REST API truly isn't working: 1. Check for security plugins (Wordfence, iThemes Security) 2. Check if REST API is disabled: Look for disable_rest_api option 3. Check firewall/CDN settings (Cloudflare, Sucuri) 4. Check server-level authentication

Whitelist OptimizePress Routes

If using OptimizePress, whitelist these paths:

• /wp-json/op3/v1/
• /wp-json/opf/v1
• /wp-json/opd/v1
• /wp-json/opc/v1
• /wp-json/opm/v1

---

SSL Certificate Issues

Check SSL Certificate Status

echo | openssl s_client -servername your-site.com -connect your-site.com:443 2>/dev/null | openssl x509 -noout -dates -subject -issuer

Verify Certificate Details

Look for:

• Issuer: Should be Let's Encrypt
• Valid dates: Check expiration
• Subject: Should match your domain

Coolify Auto-SSL Configuration

Coolify uses Traefik with Let's Encrypt. Check these labels in your service:

traefik.http.routers.https-*.tls.certresolver=letsencrypt
traefik.http.routers.https-*.tls=true

Force SSL Renewal

If certificate is expired or invalid: 1. Go to Coolify dashboard 2. Navigate to your service 3. Click on the domain configuration 4. Regenerate SSL certificate

Certificate Auto-Renewal

Coolify automatically renews Let's Encrypt certificates before expiration. No manual intervention needed unless there's an error.

---

Container Restart Required?

After making changes to .htaccess or PHP configuration, you may need to restart:

Via Coolify CLI

coolify service restart SERVICE_UUID

Via Coolify Dashboard

1. Go to your service 2. Click "Restart" button

Via API

curl -X POST \
  -H "Authorization: Bearer YOUR_TOKEN" \
  https://your-coolify-instance.com/api/v1/services/SERVICE_UUID/restart

---

Debugging Workflow

When WordPress site is down:

1. Check service status

   coolify resource list

2. Check logs

   coolify app logs APP_UUID

3. Access container terminal

• Via Coolify dashboard → Terminal
• Or via docker exec

4. Check .htaccess

   cd /var/www/html
   cat .htaccess

5. Test REST API

   curl https://your-site.com/wp-json/

6. Check SSL

   curl -vI https://your-site.com 2>&1 | grep -i ssl

7. Restart if needed

   coolify service restart SERVICE_UUID