coolify

Q: How do I install coolify?

Run npx skills add https://github.com/oakoss/agent-skills --skill coolify in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/coolify/ (personal) or .claude/skills/coolify/ (project).

by oakossDevOps & Cloud

Coolify self-hosted PaaS for deploying applications, databases, and services via REST API and Git integration. Covers API authentication, deployment triggers, build packs (Nixpacks, Dockerfile, Compose), CI/CD with GitHub Actions webhooks, environment management, and Traefik proxy configuration. Use when deploying apps to Coolify, triggering deployments via API, configuring build packs, setting up GitHub Actions CI/CD pipelines, managing environment variables, or troubleshooting deployment failures.

Installs: 361
Last 24h: —
Trending rank: —
Security: Not audited

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/oakoss/agent-skills --skill coolify

01
Install
Run the command in your project. The CLI asks which agents to install for.
02
Describe the task
Ask your agent for something this skill covers. It loads coolify automatically when relevant.
03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.

SKILL.md

The instructions your agent reads when the skill is triggered.

Coolify

Overview

Coolify is a self-hosted PaaS (Vercel/Netlify alternative) that deploys applications, databases, and services on your own infrastructure. It provides a REST API for programmatic control, supports multiple build packs, and uses Traefik for reverse proxy and SSL.

When to use: Deploying applications to self-hosted infrastructure, managing databases and services through API, automating deployments via CI/CD, self-hosting without vendor lock-in.

When NOT to use: Initial Coolify server installation (use the official install script via browser), managing Coolify's own infrastructure (Postgres, Redis — managed internally), or when a managed platform (Vercel, Railway) meets your needs without self-hosting requirements.

Quick Reference

Pattern	Approach	Key Points
API auth	`Authorization: Bearer <token>` header	Token created in dashboard, scoped permissions
List applications	`GET /api/v1/applications`	Returns all apps with status and config
Trigger deploy	`GET /api/v1/deploy?uuid=<app>&force=true`	Or use per-app webhook URL
Create application	`POST /api/v1/applications/public`	Requires project_uuid, server_uuid, env_name
Update application	`PATCH /api/v1/applications/<uuid>`	Accepts build, health check, domain, limit fields
Auto-deploy	Enable in Advanced > General	Deploys on every push to configured branch
Webhook deploy	`curl GET <webhook_url> -H "Authorization: Bearer ..."`	Controlled deploys from CI pipelines
GitHub Actions deploy	Build image, push to registry, trigger webhook	Full control over build + test before deploy
Nixpacks build	Auto-detected from source code	Zero-config for supported languages
Dockerfile build	Set build pack to `dockerfile`	Full control over build process
Compose build	`docker-compose.yaml` as source of truth	Multi-service stacks with Coolify labels
Environment variables	API or dashboard per-environment	Interpolated in Compose via `${VAR}` syntax
Domain routing	`fqdn` field or Traefik labels in Compose	Automatic SSL via Let's Encrypt
Health checks	Configurable path, interval, retries via API	Required for `running:healthy` status

Common Mistakes

Mistake	Correct Pattern
API returns "Unauthenticated"	Add `Accept: application/json` header alongside Bearer token
Can't read sensitive fields (auto-deploy, etc.)	Token needs `view:sensitive` or `*` permission scope
Auto-deploy not triggering	Verify GitHub App is connected and auto-deploy enabled in Advanced
Using API token without deploy permission	Token needs explicit `deploy` permission to trigger deployments
Health check fails on Compose services	Add `exclude_from_hc: true` label for non-HTTP services
Webhook deploy without auth header	Always include `Authorization: Bearer <token>` with webhook calls
Environment variables not available in build	Use build arguments in Advanced menu, not runtime env vars
Compose services can't communicate	Use service names as hostnames within the same stack network

Delegation

API exploration: Use Explore agent to discover existing Coolify resources
Dockerfile optimization: Use Task agent to review Dockerfiles for Coolify deployment
CI/CD pipeline design: Use Plan agent for deployment workflow strategy

If the docker skill is available, delegate Dockerfile authoring, multi-stage builds, and image optimization to it. If the github-actions skill is available, delegate workflow syntax and CI pipeline patterns to it. If the ci-cd-architecture skill is available, delegate deployment strategy and environment promotion to it.

References

API: authentication, endpoints, common operations, and permission scopes
Deployment: auto-deploy, webhooks, GitHub Actions, and CI/CD pipelines
Build packs: Nixpacks, Dockerfile, Compose conventions, and configuration

FAQ

What does the coolify skill do?

How do I install coolify?

Run npx skills add https://github.com/oakoss/agent-skills --skill coolify in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/coolify/ (personal) or .claude/skills/coolify/ (project).

Which AI agents can use coolify?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is coolify safe to install?

No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.

Who maintains coolify?

It is published by oakoss in oakoss/agent-skills. It has 361 recorded installs.

More from oakoss/agent-skills

View all →

ui-ux-polish

oakoss/agent-skills

Iterative UI/UX polishing workflow for web applications. Use when improving visual polish, refining desktop and mobile UX separately, running iterative enhancement cycles, applying design patterns like glassmorphism or bento grids, or auditing accessibility and WCAG compliance. Use for Stripe-level visual quality, responsive optimization, and design system alignment.

Frontend & Design541 installs