# Coolify y Claude Code: despliega un proyecto en tu propio VPS > Instalación de Coolify, conexión con GitHub, despliegue de Next.js, dominio y HTTPS, MCP, requisitos del VPS y solución de problemas. Precios técnicos denominados en dólares y limitaciones originales. Source: https://ailoot.ai/blog/es/coolify-claude-code-deploy/ Canonical: https://ailoot.ai/blog/es/coolify-claude-code-deploy/ Language: es Publisher: Ailoot (https://ailoot.ai/) Translation: guide-087 Revision: sha256-d4d9bedc671b29b957483b1adb8c07dfe0a1cdc3e9afc1a2129fa6e259c5eb41
[Documentación de Ailoot](https://ailoot.ai/docs/) — materiales de referencia para trabajar con el servicio.
## Limitaciones de la plataforma y condiciones de pago en 2026
Punto clave Los planes gratuitos funcionan hasta que superas un límite por primera vez; después, necesitas una tarjeta internacional. Heroku cerró su plan gratuito para todo el mundo en 2022 y entró en modo de mantenimiento en febrero de 2026. Con Coolify autoalojado, el servidor es tuyo; no hay facturación por usuario ni dependencia del proveedor.
Un escenario típico de vibe coding en 2026: creas un MVP en Cursor o Claude Code en una tarde, lo pasas a un repositorio de GitHub, abres vercel.com → conectas el repositorio → llegas a la pantalla de suscripción → introduces tu tarjeta → recibes `Transaction declined`. No es un error ni una interrupción temporal del servicio. Railway, Render y Heroku: la misma historia. De hecho, Heroku cerró su plan gratuito para todo el mundo en 2022 y, en febrero de 2026, el proyecto entró en modo de mantenimiento: sin nuevas funciones ni nuevos contratos Enterprise. Para un usuario con una tarjeta no admitida, esto significa: «la puerta está cerrada; pasa por un intermediario que cobra una comisión del 20 %». Puedes pagar con tarjetas Visa virtuales de Kazajistán o mediante servicios de pago corporativos. Pero eso implica un +20 % en el precio, +30 minutos por cada transacción y el riesgo de que bloqueen tu cuenta si el procesador de pagos detecta una discrepancia de país. El ejemplo original incluía tres intentos: con Vercel Pro, Railway y Render. ## ¿Qué es Coolify y cómo funciona una plataforma autoalojada?
Punto clave Coolify es una PaaS de código abierto que puedes autoalojar y una alternativa directa a Heroku, Vercel y Netlify. Se instala con un único comando curl en cualquier VPS que ejecute Ubuntu. Por debajo, utiliza Docker + Traefik como proxy inverso y Let's Encrypt para HTTPS. Admite la integración con GitHub, webhooks para despliegues automáticos, copias de seguridad en S3 y más de 280 servicios que se instalan con un clic (PostgreSQL, Redis, MinIO). La versión autoalojada es gratis para siempre y no tiene límites. Tiene 55,800 estrellas en GitHub y una licencia Apache-2.0.
Coolify es un proyecto de código abierto creado con Laravel + Docker que convierte cualquier VPS vacío en una plataforma de despliegue de aplicaciones. Instala Coolify una vez y luego haz todo lo demás desde la interfaz web: conecta GitHub, elige un repositorio y haz clic en Deploy. La documentación oficial lo resume de forma breve y precisa:

Coolify es una alternativa de código abierto y autoalojable a Heroku / Netlify / Vercel, etc.

— README de Coolify en GitHub, https://github.com/coollabsio/coolify
Por debajo, Coolify consta de cuatro partes: 1. **Interfaz web creada con Laravel 12 + Livewire 3 + Tailwind v4** — un panel para gestionar tus aplicaciones. 2. **Docker + Docker Compose** — cada aplicación se ejecuta en un contenedor aislado de los demás. 3. **Proxy inverso (Traefik o Caddy)** — recibe el tráfico HTTP/HTTPS entrante y lo dirige a los contenedores. 4. **Integración con Let's Encrypt** — emite y renueva automáticamente certificados SSL para todos los dominios. Funciones clave que hacen que Coolify sea funcionalmente comparable a Vercel: | Función | Vercel | Coolify | |----|----|----| | Despliegue automático al hacer git push | ✅ | ✅ (mediante webhook de GitHub) | | HTTPS gratuito | ✅ | ✅ (Let's Encrypt) | | Despliegues de vista previa de PR | ✅ | ✅ (mediante GitHub App) | | Interfaz de variables de entorno | ✅ | ✅ | | Copias de seguridad de bases de datos | ❌ (no incluye bases de datos propias) | ✅ (en almacenamiento compatible con S3) | | PostgreSQL / Redis / MongoDB | \$20+/mes cada uno | ✅ Gratis, con un clic | | Tareas programadas (cron) | ❌ | ✅ (sintaxis cron) | | Facturación por usuario | \$20/usuario/mes | Ninguna | | Dependencia del proveedor | Alta (Edge Functions, ISR) | Ninguna (tu Docker) | | CDN global | ✅ | ❌ (solo tu VPS) | Un CDN global es lo único que Coolify no incluye de fábrica. Esa es la respuesta sincera. Si tu proyecto tiene una audiencia global y necesitas reducir la latencia para los usuarios de EE. UU. y Europa, coloca Cloudflare delante; es gratis para contenido estático. Precio: **la versión autoalojada es gratis para siempre**, sin límites en el número de aplicaciones, servidores o despliegues. Coolify Cloud está disponible por \$5/mes para 2 servidores + \$3 por cada servidor adicional, pero los servidores siguen siendo tuyos; Coolify Cloud solo aloja el panel. La versión más reciente es la **v4.1.0 del 18 de mayo de 2026**. Entre las novedades están el build pack Railpack en beta, el registro de auditoría, las diferencias de configuración entre despliegues y un endpoint MCP nativo (de solo lectura). Fuente: [versiones de GitHub](https://github.com/coollabsio/coolify/releases). ## ¿Qué VPS deberías elegir para Coolify en 2026?
Punto clave Coolify requiere como mínimo 2 vCPU, 2 GB de RAM, 30 GB de SSD y Ubuntu LTS (20.04, 22.04 o 24.04). Un VPS así puede ejecutar sin problemas 3–5 proyectos de vibe coding en paralelo.
Los requisitos mínimos de Coolify proceden directamente de la [documentación oficial](https://coolify.io/docs/get-started/installation): | Parámetro | Mínimo | Recomendado | |-------------|----------------------------------|---------------------------| | CPU | 2 núcleos | 2–4 núcleos | | RAM | 2 GB | 4 GB (con margen para las compilaciones) | | Almacenamiento | 30 GB | 50–80 GB (para imágenes + bases de datos) | | Arquitectura | AMD64 o ARM64 (64 bits) | AMD64 | | SO | Ubuntu LTS 20.04 / 22.04 / 24.04 | 22.04 LTS | | Root | Obligatorio | Mediante clave SSH, no con contraseña | El mínimo de 2 GB de RAM es un **límite inferior estricto**. Con 1 GB, el instalador llega hasta Docker, se queda sin memoria (OOM) y se bloquea. No escatimes en RAM. Fuentes de precios: [Timeweb Cloud](https://timeweb.cloud/services/vds-vps), [FirstVDS](https://firstvds.ru/products/vds_vps_hosting) y [Selectel](https://selectel.ru/services/cloud/vps-vds). Si necesitas más potencia (una base de datos de 100 GB, varias instancias de Postgres), contrata Aeza Dedicated. Qué NO debes contratar: - **Un VPS compartido con 512 MB–1 GB de RAM** — ni siquiera alcanza para Coolify. Es para sitios estáticos con nginx, no para una PaaS. ¿Quieres no solo configurar el despliegue, sino también crear una **configuración que haga fiable a Claude**? Coolify es una herramienta de ejecución, pero sin contexto estructurado ([`CLAUDE.md`](https://ailoot.ai/blog/es/claude-md-template/), un [Second Brain](https://ailoot.ai/blog/es/claude-code-second-brain/) y [Context Engineering](https://ailoot.ai/blog/es/context-engineering/)), Claude seguirá alucinando en tareas largas. La configuración completa incluye los tres elementos: **clon de IA + Second Brain + Context Engineering** — esta combinación convierte a Claude de «un asistente que alucina» en una herramienta fiable. ## Cómo instalar Coolify en 5 minutos
Punto clave La instalación se hace con un único comando curl de la documentación. Cuando se inicia, aparece una interfaz web en el puerto 8000. Allí creas el primer usuario administrador y ves un panel vacío. En realidad, desde una instalación limpia de Ubuntu hasta tener Coolify en funcionamiento se tarda 5–7 minutos, de los cuales 3–4 se dedican a `apt-get install docker`. El script descarga las dependencias necesarias y configura Docker por sí solo; tú solo tienes que esperar a que termine.
**Paso 1. Conéctate al VPS mediante SSH.** Después de crear un VPS con el proveedor, la dirección IP del servidor y la contraseña de root aparecerán en un correo electrónico o en el panel de control. Conéctate desde tu equipo local: ```bash ssh root@1.2.3.4 ``` Si el proveedor te dio una clave SSH en lugar de una contraseña, conéctate con `-i path/to/key`. A partir de aquí, suponemos que tienes una instalación limpia de Ubuntu 22.04 o 24.04 LTS. **Paso 2. Ejecuta el comando de instalación de Coolify.** Un comando de la [documentación oficial](https://coolify.io/docs/get-started/installation): ```bash curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash ``` El script hace tres cosas: 1. Comprueba el sistema (¿Ubuntu LTS? ¿root? ¿AMD64?) 2. Instala Docker y Docker Compose si aún no están instalados 3. Descarga las imágenes de Coolify (`coolify/coolify`, `coolify/realtime`, `traefik`) y las ejecuta en segundo plano mediante docker-compose Esto tarda 3–5 minutos. Verás cómo pasan los registros de `apt-get`, seguidos de `docker pull`. Cuando aparezca `Coolify v4.1.0 is now running`, ve al paso 3. **Paso 3. Abre la interfaz web.** Abre esto en el navegador: ``` http://1.2.3.4:8000 ``` Coolify mostrará un asistente de configuración: un formulario para crear el primer usuario. Introduce un correo electrónico y una contraseña, y guárdalos. Este usuario se convierte automáticamente en administrador; todavía no necesitas otros usuarios. Después de guardar, llegarás a un panel vacío: una barra lateral a la izquierda con Resources / Projects / Servers / Sources / Notifications / Settings y, en el centro, una indicación para «Add your first resource». **Paso 4. Abre los puertos en el firewall del proveedor (no en UFW).** Coolify ya está en marcha, pero desde el exterior solo se puede acceder al puerto 8000 (el panel). Para que los usuarios puedan acceder a tus aplicaciones, debes abrir los puertos 80 (HTTP) y 443 (HTTPS): | Puerto | Uso | |----|----| | 22 | Acceso SSH al servidor | | 80 | Recibe tráfico HTTP; es necesario para la validación de Let's Encrypt | | 443 | Recibe el tráfico HTTPS de los usuarios | | 8000 | Panel de Coolify (lo cerraremos después de configurar un dominio personalizado para el panel) | Un problema importante señalado en la documentación oficial:

Docker utiliza reglas de iptables basadas en NAT que pueden eludir los firewalls tradicionales de Linux, como UFW.

— Documentación de Coolify (firewall), https://coolify.io/docs/knowledge-base/server/firewall
Eso significa que, aunque actives UFW y cierres todos los puertos, Docker seguirá exponiendo sus contenedores mediante iptables. Aquí UFW no sirve. La solución es **abrir y cerrar los puertos en el panel de control del proveedor**, no mediante UFW. En Timeweb / Selectel / Aeza, se hace en la sección «Network → Firewall» de la consola web. **Paso 5 (opcional). Asocia el panel a tu dominio.** Para visitar `https://coolify.example.com` en lugar de `http://1.2.3.4:8000`, crea un registro DNS A `coolify.example.com → 1.2.3.4`, ve a **Settings → Instance Settings → Instance Domain** en Coolify, introduce tu subdominio y guarda. Coolify solicitará un certificado de Let's Encrypt y, un minuto después, volverá a cargar el panel mediante HTTPS. Después puedes cerrar el puerto 8000 en el firewall; se podrá acceder al panel mediante HTTPS en el puerto estándar 443. ## Cómo conectar GitHub: ¿App o PAT?
Punto clave Coolify admite dos formas de conectar GitHub: **GitHub App** (recomendada) y **Personal Access Token (PAT)**. Usa GitHub App: la configuración con el asistente tarda 5 minutos, funcionan las vistas previas de PR y los permisos se pueden limitar con precisión a nivel de repositorio. PAT es una opción obsoleta para casos heredados; no permite despliegues de vista previa y conlleva el riesgo de acceso global a todos tus repositorios. La documentación oficial lo dice directamente: «para el 95 % de los usuarios, GitHub App es la opción adecuada».
En Coolify, ve a **Sources → + Add → GitHub App**. Coolify mostrará un asistente de tres pantallas: 1. **Name & description** — asigna un nombre a la fuente (introduce `github-main`) y, si quieres, añade una descripción. 2. **Configure on GitHub** — un botón que te lleva a GitHub.com y abre automáticamente un formulario para crear una GitHub App con los permisos correctos. 3. **Confirm** — al volver de GitHub, haz clic en «Save». En el segundo paso, GitHub te pedirá que confirmes los permisos que solicita Coolify: | Permiso | Nivel | Finalidad | |-----------------|------------|----------------------------------------------| | Contents | Solo lectura | Clonar el repositorio | | Pull Requests | Lectura y escritura | Crear despliegues de vista previa y comentar en PR | | Direcciones de correo electrónico | Solo lectura | Identificar commits | | Metadata | Solo lectura | Enumerar repositorios | Son **permisos mínimos**: GitHub App no puede ver tus claves privadas, no puede escribir en `main` y no puede acceder a repositorios que no hayas conectado explícitamente. Según la documentación oficial: Personal Access Token (PAT) es el método antiguo; **recomiendo no usarlo**. Desventajas: - PAT concede acceso global a todos tus repositorios (incluidos los privados) - Las vistas previas de PR no funcionan: esa función es exclusiva de GitHub App - El token dura mucho tiempo (90 días, un año o indefinidamente); si se filtra, es un problema Usa PAT solo si trabajas con un repositorio de una organización cuya política de seguridad prohíbe GitHub Apps y no hay forma de evitarlo. Después de guardar la fuente en Coolify, verás la GitHub App en el panel con una lista de los repositorios conectados. Cuando crees una aplicación nueva, podrás seleccionar cualquiera de ellos con un clic. ## Cómo desplegar un proyecto Next.js desde Claude Code en 6 pasos
Punto clave El recorrido completo desde una configuración vacía de Claude Code hasta un sitio en línea: 1) ejecuta `claude` en una carpeta vacía, describe el proyecto y Claude genera el código; 2) ejecuta `git init && git remote add` (Claude puede hacerlo por su cuenta mediante un comando slash); 3) sube el código a GitHub; 4) en Coolify, elige «+ New Resource → Application» y selecciona el repositorio; 5) añade las variables de entorno; 6) haz clic en Deploy. Coolify detectará que es Next.js, elegirá el build pack Nixpacks, creará una imagen Docker en 3–5 minutos y proporcionará un dominio temporal con HTTPS listo para usar.
**Paso 1. Describe el proyecto a Claude Code en una carpeta vacía.** ```bash mkdir my-vibe-app cd my-vibe-app git init claude ``` En la sesión: ``` Build a Next.js 14 app router project: - a home page with a list of users - /api/users endpoint returns an array from the database - Postgres via Prisma - Tailwind for styles - .env.example with DATABASE_URL - README.md with instructions for running the project ``` Claude generará la estructura de archivos, package.json, prisma/schema.prisma y .env.example. Pídele también: ``` Create a Dockerfile for production builds and a .dockerignore. ``` Es opcional: Coolify compilará con Nixpacks incluso sin Dockerfile. Pero un Dockerfile te permite controlar el proceso y es más rápido en proyectos grandes. **Paso 2. Crea un repositorio de GitHub y sube el código.** Puedes hacerlo manualmente desde la interfaz de GitHub + `git remote add origin ...`, pero Claude Code también puede hacerlo por su cuenta: ``` /commit-push-pr Initial Next.js app generated with Claude Code ``` O simplemente di: «Haz commit de todo y súbelo a un nuevo repositorio `my-vibe-app` en mi cuenta». Claude usará la CLI `gh` para crear un repositorio privado (o público) y hacer el primer push. Fuente: [comando oficial de Claude Code](https://github.com/anthropics/claude-code/blob/main/.claude/commands/commit-push-pr.md). **Paso 3. Crea una aplicación en Coolify.** En el panel de Coolify, haz clic en **+ New → Application**. Se abrirá un formulario: 1. **Source** — selecciona `github-main` (la GitHub App que conectaste en el H2 anterior) 2. **Repository** — selecciona `my-vibe-app` de la lista 3. **Branch** — `main` 4. **Build Pack** — Coolify lo detectará automáticamente. Si hay un Dockerfile, usará `dockerfile`. Si no, usará `nixpacks`. Puedes cambiarlo manualmente. 5. **Domain** — deja por ahora el valor sugerido (dominio wildcard gratuito); es temporal y luego lo sustituirás por tu propio dominio 6. **Port** — `3000` por defecto para Next.js Guarda. **Paso 4. Añade las variables de entorno.** En la aplicación creada, abre la pestaña **Environment Variables**. Añade las variables una por una: ``` DATABASE_URL=postgresql://user:pass@db-host:5432/mydb NODE_ENV=production ANTHROPIC_API_KEY=sk-ant-... ``` Si no tienes una base de datos, crea una directamente en Coolify: **+ New → Database → PostgreSQL**. Coolify iniciará un contenedor de Postgres en 30 segundos y proporcionará una DATABASE_URL interna con el formato `postgresql://postgres:pass@postgres-xyz:5432/postgres`; añádela a tu aplicación. Todas las variables se cifran en la base de datos de Coolify y no aparecen en los registros de compilación. **Paso 5. Haz clic en Deploy.** En la esquina superior derecha hay un botón azul Deploy. Los registros en directo aparecerán en la pestaña Logs: ``` [stage: clone] Cloning '' [stage: build] Detected Next.js, using Nixpacks [stage: build] Installing Node 20, npm 10 [stage: build] npm install (245s) [stage: build] npm run build (87s) [stage: deploy] Creating container my-vibe-app-xyz [stage: deploy] Container started, health check passed [stage: proxy] Traefik routing configured for a temporary wildcard domain [stage: ssl] Let's Encrypt cert issued for a temporary wildcard domain ``` La primera compilación tarda 3–5 minutos (descarga la imagen base de Node e instala dependencias). Las siguientes tardan 60–90 segundos gracias a la caché de capas de Docker. Cuando cambie a **Running**, copia la URL de aplicación del campo **Domains** de Coolify y abre esa dirección exacta. Úsala como `` más abajo; la etiqueta entre ángulos es un marcador, no una dirección real. Debería aparecer tu página de inicio, con HTTPS listo para usar. Un servicio DNS wildcard gratuito resuelve cualquier subdominio que contenga una dirección IP (`1-2-3-4` → `1.2.3.4`). Coolify lo utiliza para dominios temporales, de modo que puedas abrir el sitio enseguida sin configurar tu propio DNS. **Paso 6. Comprueba que todo funciona.** Abre la URL de aplicación anterior añadiendo `/api/users`, por ejemplo `/api/users`, sin duplicar la barra. Es el endpoint JSON creado en el paso 1; la raíz de la aplicación es la página de inicio. Si se produce un error 500, verás el stack trace en la pestaña Logs. El problema más frecuente en el primer despliegue es que DATABASE_URL apunte a una base de datos inexistente. Para solucionarlo, crea una instancia de PostgreSQL en Coolify (consulta el paso 4) y sustituye DATABASE_URL. 15 minutos desde el momento en que pides el VPS. En el ejemplo original, este flujo tardó 12–18 minutos en un servidor recién instalado. ## Cómo configurar un dominio personalizado y HTTPS
Punto clave Un dominio personalizado se conecta en 3 pasos: crea un registro DNS A que apunte a la IP del servidor, introduce tu dominio en la configuración de Coolify en lugar del dominio temporal, activa Automatic HTTPS y haz clic en Redeploy. Let's Encrypt emitirá automáticamente un certificado SSL 2–3 minutos después de que se propague el DNS (normalmente 5–30 minutos). El requisito clave es que el DNS ya resuelva cuando hagas clic en Redeploy; de lo contrario, la validación de Let's Encrypt fallará y tendrás que esperar 12 minutos antes del siguiente intento.
**Paso 1. Crea un registro DNS A en el panel de control de tu registrador.** Los ejemplos originales utilizan dominios alojados en Reg.ru, Beget o Timeweb. El proceso es el mismo: | Tipo de registro | Nombre | Valor | |------------|---------------------------|------------------------| | A | `app` (o `@` para la raíz) | `1.2.3.4` (IP del servidor) | Guárdalo, abre una consola y comprueba: ```bash dig app.example.com +short # Debería devolver 1.2.3.4 ``` Si no devuelve nada o aparece otra IP, el DNS aún no se ha propagado. Espera 5–30 minutos. **Paso 2. Introduce tu dominio en Coolify.** En la aplicación, abre la pestaña **Configuration → General**. En el campo **Domains**, sustituye la URL temporal copiada de Coolify por `https://app.example.com` (con tu propio dominio configurado). Activa **Automatic HTTPS** (normalmente está activado de forma predeterminada). Guarda y haz clic en **Redeploy**. **Paso 3. Espera el certificado de Let's Encrypt.** Los registros de compilación mostrarán: ``` [stage: ssl] Requesting Let's Encrypt cert for app.example.com [stage: ssl] HTTP challenge sent to /.well-known/acme-challenge/xxx [stage: ssl] Validation passed, cert issued [stage: ssl] Cert installed, HTTPS enabled ``` En 2–3 minutos, tu sitio estará disponible en `https://app.example.com`, con un candado verde en la barra de direcciones. Los 3 problemas principales que pueden surgir con Let's Encrypt aparecen en la [guía oficial de solución de problemas](https://coolify.io/docs/troubleshoot/dns-and-domains/lets-encrypt-not-working): 1. **El puerto 80 está cerrado en el firewall.** Let's Encrypt valida mediante un desafío HTTP: envía una solicitud a `http://app.example.com/.well-known/acme-challenge/xxx`. Sin el puerto 80, la validación no se completará. Ábrelo en el firewall del proveedor. 2. **El proxy de Cloudflare está activado (nube naranja).** Intercepta la solicitud de Let's Encrypt y devuelve su propia página provisional; la validación falla. La solución es cambiar a «DNS only» (nube gris) o configurar un desafío DNS-01 mediante la API de Cloudflare. 3. **El DNS aún no se ha propagado.** Si creaste un registro A hace 30 segundos y enseguida hiciste clic en Redeploy, Let's Encrypt todavía no verá tu dominio. Espera 5–30 minutos a que el DNS se propague entre los servidores. Límite de solicitudes de Let's Encrypt: **5 intentos fallidos por hora para un dominio**, con recuperación a razón de 1 intento cada 12 minutos. Si alcanzas el límite, no hagas clic en Redeploy 10 veces seguidas; revisa los registros, soluciona el problema y vuelve a intentarlo en 12 minutos. ## ¿Cómo gestiona Coolify el agente de inteligencia artificial Claude Code mediante MCP? {#cómo-gestiona-claude-code-coolify-mediante-mcp}
Punto clave A través del Model Context Protocol, Claude Code obtiene acceso directo a la API de Coolify: puedes decir «despliega esta aplicación» para iniciar una compilación, comprobar el estado, leer registros o actualizar variables de entorno. Hay tres opciones: forsonny/Coolify-MCP-Server (básica, 7 categorías de operaciones), dazeb/coolify-mcp-enhanced (más de 15 herramientas adicionales y despliegue de bases de datos con un clic) y ajmcclary/Coolify-Manager (un Claude Skill basado en la CLI oficial). Desde la v4.1.0 (18 de mayo de 2026), Coolify ofrece un endpoint MCP nativo sin servidores de terceros, aunque por ahora es de solo lectura.
Model Context Protocol (MCP) es un estándar de Anthropic que permite a Claude Code comunicarse con sistemas externos (consulta la [guía de servidores MCP](https://ailoot.ai/blog/es/mcp-servers-claude-code/) para obtener más información). Conecta un servidor MCP y Claude obtiene un conjunto de herramientas que puede invocar. Hay tres servidores preparados para Coolify y una opción nativa. **Opción 1. forsonny/Coolify-MCP-Server-for-Claude-Code — básica.** Qué puede hacer: - **Aplicaciones:** crear, iniciar, detener, reiniciar - **Servicios:** listar, crear, iniciar/detener/reiniciar - **Despliegues:** ver los que están en curso, recuperar por UUID - **Equipos y miembros:** listar, consultar información - **Claves SSH:** listar, crear - **Variables de entorno:** CRUD completo para aplicaciones y servicios - **Información del servidor:** dominios por servidor, estado, versión Instalación: ```bash git clone '' cd Coolify-MCP-Server-for-Claude-Code npm install npm run build # In .env: # COOLIFY_BASE_URL=https://coolify.example.com # COOLIFY_API_TOKEN=[from Coolify Settings → API Tokens] npm run setup # automatically configures Claude Code ``` Después, puedes escribir esto en Claude Code: ``` Show the status of the my-vibe-app application in Coolify and the 3 latest deployments. ``` Claude te devolverá una tabla. **Opción 2. dazeb/coolify-mcp-enhanced — ampliada (recomendada).** Qué añade al conjunto básico: - **Despliegue de PostgreSQL / Redis / MinIO con un clic mediante IA** — pide «configura Postgres por mí» y crea un contenedor y devuelve DATABASE_URL - **Supervisión en tiempo real + uso de recursos** — CPU/RAM de cada aplicación en tiempo real - **Actualizaciones masivas de la configuración env** — actualiza 20 variables con un solo comando - **Compatibilidad con Docker Compose** — despliega aplicaciones con varios servicios Configuración para Claude Code (`.mcp.json` en la raíz del proyecto): ```json { "mcpServers": { "coolify-enhanced": { "command": "node", "args": ["/path/to/coolify-mcp-enhanced/dist/index.js"], "env": { "COOLIFY_ACCESS_TOKEN": "your-token-here", "COOLIFY_BASE_URL": "https://coolify.example.com" } } } } ``` **Opción 3. ajmcclary/Coolify-Manager — un Claude Skill basado en la CLI.** No es un servidor MCP, sino un Claude Code Skill que envuelve la CLI oficial de Coolify. Incluye: - Diagnóstico del estado de servicios y contenedores - Diagnóstico de certificados SSL - Compatibilidad con varias instancias (si tienes varios servidores Coolify) - Recetas para solucionar problemas Instalación: descarga el skill y colócalo en `~/.claude/skills/coolify-manager/`. Claude Code lo detectará y lo ofrecerá para las tareas pertinentes. **Opción 4 (novedad de mayo de 2026). MCP nativo en Coolify v4.1.0.** El registro de cambios de la v4.1.0, fechado el 18 de mayo de 2026, indica: > Se añadió compatibilidad con MCP a nivel de instancia y herramientas de solo lectura para los recursos y la API/interfaz de Coolify. Coolify ahora ofrece su propio endpoint MCP: puedes conectar Claude Code directamente, sin servidores de terceros. Por ahora es **de solo lectura** (listas de aplicaciones, estados, configuraciones) y no permite operaciones de modificación. Pero basta para la mayoría de las tareas, como «cuéntame cómo es la infraestructura». Conéctalo mediante `.mcp.json`: ```json { "mcpServers": { "coolify-native": { "url": "https://coolify.example.com/api/v1/mcp", "headers": { "Authorization": "Bearer " } } } } ``` Espera a que el MCP nativo tenga acceso completo de escritura en la v4.2 o v4.3: el equipo de Coolify lo prometió para finales de 2026. ## 5 obstáculos en tu primer despliegue y cómo evitarlos
Punto clave Los errores más frecuentes en un primer despliegue son tener poca RAM, dejar cerrado el puerto 80, que el proxy de Cloudflare interrumpa Let's Encrypt, que UFW no proteja Docker y elegir PAT en vez de GitHub App. Todos están cubiertos en la documentación oficial, pero es fácil encontrárselos sin experiencia práctica. A continuación encontrarás una lista de comprobación de 5 puntos basada en la experiencia original de instalar Coolify por primera vez.
**Obstáculo 1: menos de 2 GB de RAM — la instalación falla con OOM.** Síntoma: `curl install.sh` llega a `docker pull coolify/coolify`, se bloquea en el 70 % y el proceso termina con `Killed (signal 9)`. Los registros de `dmesg | tail` muestran `Out of memory: Killed process`. Solución: ```bash # Crea un archivo swap de 4 GB para resolver el problema temporalmente sudo fallocate -l 4G /swapfile sudo chmod 600 /swapfile sudo mkswap /swapfile sudo swapon /swapfile echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab ``` A largo plazo, amplía la RAM a 4 GB. Coolify funciona con swap, pero pueden fallar las compilaciones de proyectos grandes de Next.js. **Obstáculo 2: UFW está activado, pero Docker sigue abriendo puertos.** Síntoma: activaste UFW y cerraste todos los puertos excepto el 22, pero tu aplicación sigue siendo accesible desde Internet por algún puerto aleatorio, como el 3000. El motivo, según la [documentación oficial](https://coolify.io/docs/knowledge-base/server/firewall):

Coolify se ejecuta sobre Docker, que utiliza reglas de iptables basadas en NAT y puede eludir los firewalls tradicionales de Linux, como UFW.

— Documentación de Coolify (firewall), https://coolify.io/docs/knowledge-base/server/firewall
Solución: utiliza el **firewall del panel de control de tu proveedor**, no UFW. Timeweb / Selectel / Aeza tienen una sección «Firewall» o «Network → Firewall» donde se configuran las reglas a nivel de red virtual; estas se aplican antes de que los paquetes lleguen a Docker. Una alternativa es ufw-docker, un script que modifica UFW para que sea compatible con Docker. Pero es más complicado que hacer clic en el panel de control. **Obstáculo 3: el proxy de Cloudflare (nube naranja) impide que funcione Let's Encrypt.** Síntoma: después de Redeploy, los registros muestran `Let's Encrypt validation failed - challenge returned 403`. Motivo: Cloudflare hace de proxy para la solicitud HTTP de Let's Encrypt y devuelve su propia página en lugar del archivo de desafío. Solución: elige una de estas dos opciones: 1. **Cambia a «DNS only»** (la nube gris de Cloudflare). Inconveniente: pierdes el CDN y la protección de Cloudflare. 2. **Configura un desafío DNS-01 mediante la API de Cloudflare.** En Coolify, ve a Settings → SSL Configuration, selecciona el proveedor Cloudflare e introduce un token de API con permisos Zone:Read y DNS:Edit. Let's Encrypt validará el dominio mediante un registro TXT en lugar de HTTP. La segunda opción es más compleja de configurar, pero conserva el proxy de Cloudflare. **Obstáculo 4: usar PAT en vez de GitHub App — las vistas previas de PR no funcionan.** Síntoma: conectaste GitHub mediante un Personal Access Token; todo funciona, pero no se crean despliegues de vista previa para las PR. Abriste una PR en GitHub, pero no apareció nada en Coolify. Motivo: las vistas previas de PR son una función exclusiva de GitHub App. PAT no recibe eventos `pull_request` mediante un webhook. Solución: vuelve a conectar GitHub mediante App. Sources → Add → GitHub App → completa el asistente. Puedes eliminar la antigua fuente PAT. **Obstáculo 5: «Coolify == Vercel» no es del todo cierto.** Lo que Coolify **no hace** de fábrica: | Vercel | Coolify | Qué hacer | |----|----|----| | CDN global | No | Coloca Cloudflare delante (gratis para contenido estático) | | Incremental Static Regeneration | No | `revalidatePath` solo funciona en tu servidor | | Optimización de imágenes | No | Usa `next/image` con un loader local o Cloudflare Images | | Escalado automático durante picos | No | Escala manualmente; mejora tu VPS | | Edge Functions | No | Usa rutas API normales | Si tu proyecto es un SaaS de alto tráfico con audiencia global y requisitos de latencia de \< 100 ms en todo el mundo, Coolify no es adecuado; elige Vercel Enterprise. Si haces vibe coding y estás probando un MVP con 100–1,000 usuarios al día, Coolify cubre todas tus necesidades. Según un análisis sincero del autoalojamiento: Los 15 minutos del título de esta guía corresponden al camino ideal para el primer despliegue de un proyecto. Una configuración completa de la infraestructura, con supervisión, copias de seguridad y alertas, lleva una o dos tardes. Sé sincero contigo mismo. ## ¿Cuánto ahorrarás en un año en comparación con Vercel?
Punto clave También existe un «impuesto oculto en tiempo» de 5–10 horas para la configuración inicial y de 1–2 horas al mes para el mantenimiento.
Las cifras de Vercel siguientes son estimaciones de escenarios de mayo de 2026, no presupuestos actuales. Solo representan un lado de la comparación. Coolify autoalojado no tiene coste de licencia, pero VPS, copias, almacenamiento, tráfico y operaciones sí cuestan. Obtén un presupuesto que cumpla los requisitos anteriores: no se aportó un precio numérico de VPS para estos escenarios y no puede afirmarse un ahorro fijo. Sea **C** la factura mensual total del VPS elegido, almacenamiento de copias, tráfico adicional, supervisión y panel de pago opcional. Incluye cada gasto una vez. Sea **r** tu coste horario de operación, usando una sola moneda. El artículo estima 5–10 horas iniciales y 1–2 mensuales: **17–34 horas el primer año** y **12–24 en años posteriores**. | Escenario | Estimación Vercel/mes | Vercel/año | Infraestructura Coolify/mes | Coste total primer año Coolify con trabajo | Ahorro primer año frente a Vercel | |----|----|----|----|----|----| | Un prototipo, 100.000 visitas/mes | $20 base + ~$5 tráfico = $25 | $300 | C | 12C + (17–34)r | $300 − 12C − (17–34)r | | Cinco proyectos en un VPS | $20 base + $30 tráfico/funciones = $50 | $600 | C | 12C + (17–34)r | $600 − 12C − (17–34)r | | Tres desarrolladores, cinco proyectos | $60 puestos + $30 tráfico = $90 | $1.080 | C | 12C + (17–34)r | $1.080 − 12C − (17–34)r | Usa una C diferente por escenario si necesitan servidores distintos. Para comparar mensualmente, reparte la configuración inicial entre 12 meses: el equivalente mensual del primer año es **C + (17–34)r/12**. El coste posterior es **12C + (12–24)r**. Incluye también operaciones comparables en Vercel. Un ahorro negativo significa que autoalojar cuesta más con tus datos. No sumes de nuevo el sueldo completo del mismo técnico si r ya lo incluye. Antes de cambiar, rellena C con una oferta real y un plan de copias, elige r y compara el uso real durante un mes. Sin esos datos, el artículo respalda un modelo de costes, no un ahorro en dólares. La principal ventaja no es el dinero. Al cambiarte a Coolify, **desaparece la categoría «depender de la política de pago de otra persona»**. Ya no necesitas tarjetas virtuales intermediarias con una comisión del 20 %. Coolify no es una versión más barata de Vercel. Es una categoría de producto diferente: eres dueño de la infraestructura, asumes la responsabilidad por ella y ahorras dinero aceptando su complejidad. Si desplegar un prototipo es tu primera tarea después de generarlo en Claude Code, gestionar el entorno (env, secretos, tareas programadas, copias de seguridad) forma parte del [**Context Engineering**](https://ailoot.ai/blog/es/context-engineering/). Sin una estructura que indique «dónde está cada cosa», Claude se pierde y tú pierdes tiempo con cada cambio. La configuración completa incluye: **clon de IA** ([Skills](https://ailoot.ai/blog/es/claude-code-skills-library/) y [Subagents](https://ailoot.ai/blog/es/claude-code-subagents/) adaptados a tu metodología) + [**Second Brain**](https://ailoot.ai/blog/es/claude-code-second-brain/) (la base de conocimiento del proyecto) + **Context Engineering** ([Plan Mode](https://ailoot.ai/blog/es/claude-code-plan-mode/), `/compact`, entorno de ejecución). Son los **3 pilares** sin los cuales la IA alucina.
### Fuentes - [Documentación oficial de Coolify: introducción](https://coolify.io/docs/get-started/introduction) - [Guía de instalación de Coolify](https://coolify.io/docs/get-started/installation) - [Descripción general de los build packs de Coolify](https://coolify.io/docs/applications/build-packs/overview) - [Base de conocimiento de Coolify: firewall](https://coolify.io/docs/knowledge-base/server/firewall) - [Solución de problemas de Let's Encrypt en Coolify](https://coolify.io/docs/troubleshoot/dns-and-domains/lets-encrypt-not-working) - [Precios de Coolify](https://coolify.io/pricing) - [Coolify en GitHub: versiones v4.1.0](https://github.com/coollabsio/coolify/releases) - [Descripción general de Claude Code](https://code.claude.com/docs/en/overview) - [VPS de Timeweb Cloud](https://timeweb.cloud/services/vds-vps) - [VPS de FirstVDS](https://firstvds.ru/products/vds_vps_hosting) - [VPS/VDS de Selectel](https://selectel.ru/services/cloud/vps-vds/) - [Precios de Vercel](https://vercel.com/pricing)
El flujo completo de contexto: **clon de IA + Second Brain + Context Engineering**. Encontrarás más materiales en [Ailoot](https://ailoot.ai/). ## Preguntas sobre Claude Code ### ¿Qué URL debe devolver JSON tras desplegar? Copia la URL de la aplicación mostrada en Domains de Coolify y abre su ruta /api/users. La raíz es la página de inicio; /api/users es el endpoint JSON especificado en el proyecto del ejemplo. ### ¿Cómo calculo si alojarlo por mi cuenta ahorra dinero? Suma VPS, copias, almacenamiento, tráfico, supervisión y panel opcional mensuales en C. El coste total del primer año es 12C más 17–34 horas a tu tarifa. Compáralo con la estimación anual de Vercel e incluye costes operativos comparables en ambos lados. ## Ailoot · La empresa y su cartera de proyectos Ailoot se apoya en la experiencia operativa acumulada, una amplia base de clientes, un servicio estable y el seguimiento continuo de KPI. La empresa y su cartera de proyectos: millones de clientes; ventas por miles de millones al mes. Ailoot aplica esa experiencia operativa al acceso por API a funciones de IA en productos de clientes, agentes, aplicaciones y automatizaciones.