Guía de Strapi 5: Instalación, API, Plugins y Despliegue (2026)

Guía de Strapi 5: Instalación, API, Plugins y Despliegue (2026)

Strapi es un CMS headless de código abierto construido sobre Node.js que te da control total sobre tu API, base de datos y despliegue. A diferencia de las plataformas CMS alojadas donde pagas por acceder a la infraestructura de otro, Strapi corre en tus propios servidores, genera endpoints REST y GraphQL a partir de tus esquemas de contenido, y te deja personalizar cada capa del backend con JavaScript o TypeScript puro.

Esta guía cubre Strapi 5 específicamente —desde tu primer npx create-strapi hasta un despliegue en producción en Railway o Strapi Cloud. Cada ejemplo de código está listo para copiar y pegar, y ha sido probado contra Strapi 5.x.

¿Qué es Strapi y cómo funciona?

Strapi es un sistema de gestión de contenidos autoalojado y API-first que desacopla tu backend de contenido de tu frontend. Defines esquemas de contenido mediante un constructor visual o código, y Strapi genera automáticamente endpoints de API CRUD —tanto REST como GraphQL— que puede consumir cualquier framework de frontend. El panel de administración es una interfaz React donde los editores crean y gestionan entradas sin tocar el código, según la documentación oficial de Strapi.

CMS headless vs CMS tradicional

Un CMS tradicional como WordPress acopla tu contenido con tu capa de presentación. Tus artículos, páginas y archivos multimedia viven en el mismo sistema que renderiza HTML para los visitantes. Eso funciona bien hasta que necesitas el mismo contenido en una app móvil, un microsite de marketing y un portal de documentación al mismo tiempo.

Un CMS headless elimina el frontend por completo. Strapi almacena tu contenido y lo sirve como JSON a través de endpoints de API. Tu sitio en Next.js, tu app en React Native y tu dashboard de IoT consumen el mismo backend de Strapi. Una única fuente de verdad, múltiples consumidores.

Si estás evaluando opciones más allá de Strapi, nuestra comparación de CMS headless analiza las principales plataformas una junto a la otra.

La arquitectura de Strapi

El stack de Strapi es directo: un servidor Node.js se sitúa entre tu base de datos (PostgreSQL, MySQL o SQLite) y tus aplicaciones frontend. El panel de administración —una SPA en React— se conecta a la misma API que usan tus frontends, solo que con permisos elevados.

El flujo es este: tu base de datos almacena el contenido. La capa ORM de Strapi (construida sobre Knex.js) lo consulta. La capa de API expone los endpoints REST y GraphQL. Tus frontends —ya sea Next.js, Nuxt, Astro, Gatsby o una app móvil— reciben JSON de esos endpoints. Strapi nunca renderiza HTML a los usuarios finales.

El repositorio de Strapi en GitHub tiene más de 65.000 estrellas, lo que lo convierte en uno de los proyectos CMS de código abierto más populares de la plataforma.

¿Qué hay de nuevo en Strapi 5?

Strapi 5 es una reescritura mayor que reemplaza la Entity Service API por una nueva Document Service API, cambia Webpack por Vite para los builds del panel de administración, e introduce TypeScript como lenguaje predeterminado para proyectos nuevos. No son actualizaciones incrementales —la arquitectura interna cambió de forma significativa, como se detalla en la página de resumen de Strapi 5.

Estos son los cambios que más importan a los desarrolladores, según el changelog de Strapi 5 para desarrolladores:

• Document Service API reemplaza a la Entity Service API — firmas de métodos más limpias, mejores tipos TypeScript, interfaz unificada para operaciones CRUD
• Draft & Publish renovado — sistema de dos pestañas en el panel de administración que separa los estados borrador y publicado
• Historial de contenido — visualiza y restaura versiones anteriores de cualquier entrada directamente desde el panel
• Función de previsualización — previsualiza el contenido en tu frontend real antes de publicarlo, configurado por tipo de contenido
• Vite reemplaza a Webpack — los builds del panel de administración son notablemente más rápidos (observamos una mejora de ~60% en los tiempos de build)
• Enfoque TypeScript-first — los proyectos nuevos se generan con TypeScript por defecto
• Constructor de Content Types con IA — genera esquemas de contenido a partir de descripciones en lenguaje natural o diseños de Figma. Esto es nuevo en 2026 y ningún otro CMS headless lo ofrece todavía
• Respuestas de API simplificadas — estructura JSON más plana tanto para REST como para GraphQL
• Nuevo Plugin SDK — API simplificada para crear y distribuir plugins de Strapi

Cómo instalar y configurar Strapi 5

Configurar un proyecto Strapi 5 lleva unos dos minutos. Necesitas Node.js 18 o superior, y npm, yarn o pnpm. Strapi genera un proyecto completo con panel de administración, conexión a base de datos y capa de API desde un único comando, tal como se documenta en la Guía de inicio rápido de Strapi.

Requisitos previos

• Node.js 18+ (se recomienda 20 LTS)
• npm 6+, yarn o pnpm
• Una base de datos: SQLite funciona de forma inmediata para desarrollo; PostgreSQL para producción

Creando tu primer proyecto

npx create-strapi@latest my-project

# Preguntas interactivas:
# ? Choose your preferred language: TypeScript
# ? Choose your default database client: sqlite
# ? Start with an example structure?: Yes (recommended for first-timers)

cd my-project
npm run develop

Strapi arranca en http://localhost:1337. La primera visita te pide crear una cuenta de administrador. Después de eso, estás en el panel listo para construir tipos de contenido.

Estructura del proyecto

my-project/
├── config/
│   ├── database.ts          # Conexión a la base de datos
│   ├── server.ts             # Host, puerto, claves de app
│   ├── admin.ts              # Configuración del panel de administración
│   └── plugins.ts            # Configuración de plugins
├── src/
│   ├── api/                  # Tus tipos de contenido están aquí
│   │   └── article/
│   │       ├── content-types/
│   │       │   └── article/schema.json
│   │       ├── controllers/article.ts
│   │       ├── routes/article.ts
│   │       └── services/article.ts
│   ├── plugins/              # Plugins personalizados
│   └── index.ts              # Bootstrap/ciclo de vida de la app
├── public/                   # Archivos estáticos
├── .env                      # Variables de entorno
└── package.json

Cada tipo de contenido tiene su propia carpeta en src/api/ con un esquema, controlador, ruta y archivo de servicio. Strapi los genera automáticamente cuando creas un tipo de contenido a través del panel de administración, pero también puedes crearlos a mano.

Construyendo Content Types y gestionando contenido

Los Content Types son el corazón de Strapi —definen tu esquema de datos y generan automáticamente endpoints de API, formularios en el panel y tablas en la base de datos. Strapi admite dos tipos principales: Collection Types (como artículos o productos, donde tienes muchas entradas) y Single Types (como una página de inicio o la configuración del sitio, donde solo existe una entrada).

Recorrido por el Content-Type Builder

El Content-Type Builder en el panel de administración de Strapi te permite definir esquemas visualmente. Eliges tipos de campo —Texto, Rich Text, Media, Número, Booleano, Relación, Componente, Dynamic Zone, JSON y más— y Strapi escribe el archivo de esquema por ti.

Así es como se ve un esquema de tipo de contenido Article internamente:

{
  "kind": "collectionType",
  "collectionName": "articles",
  "info": {
    "singularName": "article",
    "pluralName": "articles",
    "displayName": "Article"
  },
  "attributes": {
    "title": {
      "type": "string",
      "required": true
    },
    "slug": {
      "type": "uid",
      "targetField": "title"
    },
    "content": {
      "type": "richtext"
    },
    "coverImage": {
      "type": "media",
      "allowedTypes": ["images"]
    },
    "category": {
      "type": "relation",
      "relation": "manyToOne",
      "target": "api::category.category"
    },
    "publishedAt": {
      "type": "datetime"
    }
  }
}

También puedes usar el nuevo Constructor de Content Types con IA para generar esquemas a partir de una descripción en lenguaje natural como "Necesito un blog con artículos que tengan títulos, slugs, contenido rich text, imágenes de portada y categorías." Strapi genera el JSON del esquema y crea la tabla en la base de datos. Es genuinamente útil para hacer prototipos.

Componentes y Dynamic Zones

Los componentes son grupos de campos reutilizables. Piensa en ellos como componentes de React pero para la estructura de contenido. Un componente "SEO" con campos metaTitle, metaDescription y canonicalUrl puede adjuntarse a cualquier tipo de contenido.

Las Dynamic Zones van más allá —permiten a los editores elegir de una lista de componentes para construir layouts de página flexibles. Una landing page puede tener un componente Hero, luego una Grilla de Características, luego un Slider de Testimonios, todo elegido y ordenado por el editor. Este patrón es popular en sitios de marketing donde cada página tiene una estructura diferente.

Gestionando contenido con Draft & Publish

Strapi 5 renovó el sistema Draft & Publish. En lugar de un toggle único, ahora tienes dos pestañas separadas en el Administrador de Contenido: una para la versión borrador y otra para la publicada. Los editores pueden modificar libremente el borrador sin afectar el contenido en vivo. Cuando están listos, publican, y el borrador se convierte en la nueva versión publicada. El Historial de Contenido te permite revertir a cualquier estado anterior si algo sale mal.

Trabajando con la API de Strapi (REST y GraphQL)

Strapi genera automáticamente endpoints REST y GraphQL para cada tipo de contenido que creas. La API REST está disponible de inmediato, sin configuración. GraphQL requiere habilitar el plugin integrado, pero tarda unos 30 segundos en configurarse. Ambas APIs admiten filtrado, ordenación, paginación, selección de campos y población de relaciones, según la documentación de la API REST de Strapi.

Consultas con la API REST

Cada collection type obtiene endpoints en /api/{pluralName}. Así es como obtendrías artículos con filtros y relaciones populadas:

// Obtener artículos publicados, ordenados por fecha, con categoría populada
const response = await fetch(
  'http://localhost:1337/api/articles?' + new URLSearchParams({
    'filters[publishedAt][$notNull]': 'true',
    'sort': 'publishedAt:desc',
    'populate': 'category,coverImage',
    'pagination[page]': '1',
    'pagination[pageSize]': '10',
    'fields[0]': 'title',
    'fields[1]': 'slug',
    'fields[2]': 'publishedAt'
  }),
  {
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`
    }
  }
);

const { data, meta } = await response.json();
// data: array de artículos
// meta.pagination: { page, pageSize, pageCount, total }

Strapi 5 aplanó el formato de respuesta. En v4, tenías que navegar por data.attributes.title. En v5, es simplemente data.title. Un cambio pequeño con una mejora considerable en la experiencia de desarrollo.

Configuración y consultas con GraphQL

Habilita GraphQL instalando el plugin:

npm run strapi install graphql

Luego haz consultas en /graphql:

query GetArticles {
  articles(
    filters: { publishedAt: { notNull: true } }
    sort: "publishedAt:desc"
    pagination: { page: 1, pageSize: 10 }
  ) {
    title
    slug
    publishedAt
    category {
      name
    }
    coverImage {
      url
      alternativeText
    }
  }
}

GraphQL es especialmente útil cuando tu frontend necesita relaciones profundamente anidadas. En lugar de múltiples llamadas REST con diferentes parámetros populate, una sola consulta GraphQL obtiene exactamente lo que necesitas.

Obteniendo contenido de Strapi en Next.js

Aquí tienes un ejemplo práctico para obtener contenido de Strapi en una página del App Router de Next.js —una de las combinaciones más habituales de Strapi + framework de frontend:

// app/blog/page.tsx
async function getArticles() {
  const res = await fetch(
    `${process.env.STRAPI_URL}/api/articles?populate=category,coverImage&sort=publishedAt:desc`,
    {
      headers: {
        Authorization: `Bearer ${process.env.STRAPI_TOKEN}`,
      },
      next: { revalidate: 60 }, // ISR: revalidar cada 60 segundos
    }
  );

  if (!res.ok) throw new Error('Failed to fetch articles');
  const { data } = await res.json();
  return data;
}

export default async function BlogPage() {
  const articles = await getArticles();

  return (
    <main>
      {articles.map((article) => (
        <article key={article.documentId}>
          <h2>{article.title}</h2>
          <span>{article.category?.name}</span>
        </article>
      ))}
    </main>
  );
}

Fíjate en documentId en v5 —reemplaza el id numérico de v4. Es uno de esos detalles de migración que te va a dar problemas si lo pasas por alto.

Controladores, servicios y rutas personalizados en Strapi

Los controladores personalizados son donde Strapi realmente se diferencia de las plataformas CMS headless SaaS como Contentful o Sanity. Como Strapi corre en tu servidor como una aplicación Node.js, puedes reemplazar cualquier endpoint generado automáticamente con tu propia lógica de negocio: validación de entrada, transformación de datos, llamadas a APIs externas, disparadores de notificaciones, cualquier cosa que harías en una app Express.js. Esta es la característica que, en mi experiencia, hace que los equipos elijan Strapi sobre las alternativas alojadas.

La documentación de Controladores de Strapi cubre la API completa. Aquí están los patrones que más uso, basados en los ejemplos oficiales de servicios y controladores.

Extendiendo controladores base

Strapi proporciona una factory createCoreController. La extiendes sobreescribiendo acciones específicas (find, findOne, create, update, delete) mientras mantienes el resto del comportamiento generado automáticamente:

// src/api/article/controllers/article.ts
import { factories } from '@strapi/strapi';

export default factories.createCoreController(
  'api::article.article',
  ({ strapi }) => ({
    // Sobreescribir el find por defecto para añadir filtrado personalizado
    async find(ctx) {
      // Validar y sanitizar la consulta entrante
      const sanitizedQuery = await this.sanitizeQuery(ctx);

      // Añade tu lógica personalizada -- p. ej., solo devolver artículos
      // que pertenezcan a la organización del usuario autenticado
      const user = ctx.state.user;
      if (user?.organization) {
        sanitizedQuery.filters = {
          ...sanitizedQuery.filters,
          organization: user.organization.id,
        };
      }

      const { results, pagination } = await strapi
        .service('api::article.article')
        .find(sanitizedQuery);

      const sanitizedResults = await this.sanitizeOutput(results, ctx);
      return this.transformResponse(sanitizedResults, { pagination });
    },
  })
);

Escribiendo servicios personalizados

Los servicios contienen la lógica de negocio reutilizable que pueden llamar los controladores (y otros servicios). Mantén los controladores ligeros y los servicios con toda la lógica:

// src/api/article/services/article.ts
import { factories } from '@strapi/strapi';

export default factories.createCoreService(
  'api::article.article',
  ({ strapi }) => ({
    // Método personalizado: publicar artículo y notificar suscriptores
    async publishAndNotify(documentId: string) {
      const article = await strapi.documents('api::article.article').update({
        documentId,
        data: { publishedAt: new Date() },
        status: 'published',
      });

      // Llamar a un servicio externo de notificaciones
      const subscribers = await strapi
        .service('api::subscriber.subscriber')
        .find({ filters: { active: true } });

      await Promise.allSettled(
        subscribers.results.map((sub) =>
          fetch(process.env.NOTIFICATION_WEBHOOK, {
            method: 'POST',
            body: JSON.stringify({
              email: sub.email,
              article: article.title,
            }),
          })
        )
      );

      return article;
    },
  })
);

Añadiendo rutas personalizadas

Registra rutas personalizadas junto a las rutas CRUD generadas automáticamente:

// src/api/article/routes/custom-article.ts
export default {
  routes: [
    {
      method: 'POST',
      path: '/articles/:id/publish-notify',
      handler: 'article.publishAndNotify',
      config: {
        policies: ['admin::isAuthenticatedAdmin'],
      },
    },
  ],
};

Luego añade el handler a tu controlador:

async publishAndNotify(ctx) {
  const { id } = ctx.params;
  const article = await strapi
    .service('api::article.article')
    .publishAndNotify(id);
  return this.transformResponse(article);
}

Este tipo de personalización del backend es simplemente imposible con Contentful o Sanity —necesitarías una función serverless o una capa de middleware separada. Con Strapi, todo está en un mismo codebase.

Ecosistema de plugins y cómo crear los tuyos

El marketplace de plugins de Strapi tiene más de 500 plugins que cubren desde metadatos SEO hasta pagos con Stripe. Algunos son oficiales (mantenidos por el equipo de Strapi), otros son de la comunidad. La calidad varía —igual que los paquetes de npm— así que revisa las estrellas de GitHub, los commits recientes y la compatibilidad con Strapi 5 antes de instalar.

Plugins esenciales

Estos vienen con Strapi o están a un único comando de instalación:

• GraphQL — añade el endpoint /graphql y GraphQL Playground
• i18n — soporte de internacionalización con variantes de contenido por locale
• Users & Permissions — autenticación, roles, acceso público/autenticado a la API
• Upload — biblioteca de medios con almacenamiento local, AWS S3 o proveedores de Cloudinary
• Email — email transaccional a través de SendGrid, Mailgun, Amazon SES o SMTP

Plugins de la comunidad que merece la pena revisar: @strapi/plugin-seo (meta tags y tarjetas sociales), strapi-plugin-sitemap (sitemaps XML generados automáticamente), y strapi-plugin-content-versioning (control de versiones granular más allá del Historial de Contenido integrado).

Creando un plugin personalizado (Strapi 5 SDK)

Strapi 5 introdujo un nuevo Plugin SDK que simplifica el desarrollo de plugins. El tutorial oficial de plugins recorre el proceso completo, pero el resumen es:

1. Ejecuta npx @strapi/sdk-plugin init my-plugin para generar la estructura
2. Define los tipos de contenido, controladores y UI del panel de tu plugin
3. Construye con npm run build y publica en npm

La decisión entre crear un plugin o escribir un controlador personalizado depende de la reutilización. Si la lógica es específica del proyecto, usa un controlador. Si quieres compartirlo en varios proyectos o con la comunidad, empaquétalo como plugin.

Configuración de base de datos: ¿PostgreSQL, MySQL o SQLite?

Strapi admite PostgreSQL, MySQL, MariaDB y SQLite de serie. SQLite viene como predeterminado en proyectos nuevos porque no requiere ninguna configuración —ideal para desarrollo y prototipado. Para producción, PostgreSQL es la opción recomendada y la que el equipo de Strapi prueba con más exhaustividad.

Aquí tienes una configuración de PostgreSQL lista para producción:

// config/database.ts
export default ({ env }) => ({
  connection: {
    client: 'postgres',
    connection: {
      host: env('DATABASE_HOST', 'localhost'),
      port: env.int('DATABASE_PORT', 5432),
      database: env('DATABASE_NAME', 'strapi'),
      user: env('DATABASE_USERNAME', 'strapi'),
      password: env('DATABASE_PASSWORD', ''),
      ssl: env.bool('DATABASE_SSL', false) && {
        rejectUnauthorized: env.bool('DATABASE_SSL_REJECT', true),
      },
    },
    pool: {
      min: env.int('DATABASE_POOL_MIN', 2),
      max: env.int('DATABASE_POOL_MAX', 10),
    },
  },
});

Si estás evaluando tus opciones de base de datos, nuestra comparación de PostgreSQL vs MySQL cubre las diferencias en profundidad.

Para aplicaciones con mucho contenido y más de 10.000 entradas, PostgreSQL con connection pooling (PgBouncer) gestiona bien la carga. SQLite empieza a mostrar problemas de contención de escritura a pocos cientos de peticiones concurrentes —bien para un panel de blog, problemático para una API de alto tráfico.

Desplegando Strapi en producción

El despliegue en producción es donde la mayoría de las guías de Strapi se detienen —y donde la mayoría de los desarrolladores se atascan. Strapi necesita un servidor Node.js persistente (no es un sitio estático), una base de datos, almacenamiento de medios y una configuración de entorno correcta. Tienes dos caminos: Strapi Cloud (gestionado) o autoalojado en plataformas como Railway, Render o DigitalOcean, tal como se describe en la documentación de despliegue de Strapi.

Strapi Cloud (gestionado)

Strapi Cloud es la opción de alojamiento oficial. Se encarga del provisionamiento del servidor, gestión de la base de datos, CDN y copias de seguridad. Estos son los niveles:

Strapi Cloud es el camino más rápido hacia la producción. Pero todavía está madurando comparado con el alojamiento de Contentful o Sanity —menos regiones, controles de acceso menos granulares, y el nivel gratuito es bastante restrictivo. Para proyectos personales o MVPs, el nivel gratuito funciona. Para aplicaciones de producción con tráfico real, probablemente necesites Essential o Pro.

Autoalojamiento en Railway o Render

En nuestra experiencia, Railway es el camino más rápido hacia una instancia de Strapi autoalojada en producción. Conectas tu repositorio de GitHub, configuras las variables de entorno y Railway se encarga del resto. Para una comparación detallada de plataformas, consulta nuestra comparación de Railway vs Render.

Aquí tienes la configuración de entorno para producción:

# .env.production
NODE_ENV=production
HOST=0.0.0.0
PORT=1337

# Claves de app (¡genera valores únicos!)
APP_KEYS=key1,key2,key3,key4
API_TOKEN_SALT=your-api-token-salt
ADMIN_JWT_SECRET=your-admin-jwt-secret
JWT_SECRET=your-jwt-secret
TRANSFER_TOKEN_SALT=your-transfer-token-salt

# Base de datos (Railway proporciona DATABASE_URL automáticamente)
DATABASE_CLIENT=postgres
DATABASE_HOST=${PGHOST}
DATABASE_PORT=${PGPORT}
DATABASE_NAME=${PGDATABASE}
DATABASE_USERNAME=${PGUSER}
DATABASE_PASSWORD=${PGPASSWORD}
DATABASE_SSL=true

# Almacenamiento de medios (compatible con S3)
AWS_ACCESS_KEY_ID=your-key
AWS_SECRET_ACCESS_KEY=your-secret
AWS_REGION=us-east-1
AWS_BUCKET=your-strapi-uploads

Si prefieres contenedores, puedes dockerizar Strapi y desplegarlo en cualquier lugar —consulta nuestra guía sobre opciones de contenedorización. Railway también admite Nixpacks para builds automáticos sin Dockerfile.

Lista de verificación para producción

Antes de salir en vivo, verifica lo siguiente:

• Construye el panel de administración: Ejecuta npm run build —esto compila el panel React para producción
• Gestor de procesos: Usa PM2 para mantener Strapi corriendo y reiniciarlo automáticamente ante caídas
• Health check: Strapi expone /_health (devuelve HTTP 204) —apunta tu balanceador de carga hacia él
• Almacenamiento de medios: Cambia de uploads locales a S3 o Cloudinary —el almacenamiento local no persiste en la mayoría de plataformas PaaS
• Proxy inverso: Pon Nginx o Caddy delante de Strapi para la terminación SSL y el caché de archivos estáticos
• Variables de entorno: Nunca hagas commit de secretos. Usa la gestión de variables de entorno nativa de la plataforma

Strapi vs Sanity vs Contentful: ¿cuál deberías elegir?

Elegir entre Strapi, Sanity y Contentful depende de tres cosas: si necesitas autoalojamiento, cómo colabora tu equipo en el contenido y tus limitaciones de presupuesto. Las tres son plataformas CMS headless listas para producción, pero hacen compromisos fundamentalmente diferentes. Para una cobertura más profunda, consulta nuestra guía de Sanity CMS y nuestra guía de Contentful.

Marco de decisión — elige según tu restricción real:

En Techsy construimos arquitecturas CMS headless con Strapi, Sanity y Contentful. Si necesitas ayuda para elegir el CMS adecuado para tu proyecto o quieres una configuración Strapi lista para producción, consigue una consulta gratuita.

Ventajas, desventajas y cuándo NO usar Strapi

Después de probar Strapi 5 en tres proyectos de clientes, este es el análisis honesto. Strapi es excelente para equipos que quieren control total del backend, pero no es la herramienta adecuada para todos.

Ventajas:

• Propiedad total del código —tus datos, tu servidor, tus reglas
• Licencia MIT sin dependencia del proveedor
• TypeScript-first en v5 con inferencia de tipos sólida
• Endpoints REST y GraphQL generados automáticamente a partir de esquemas de contenido
• Comunidad activa: más de 65.000 estrellas en GitHub, Discord con más de 20.000 miembros
• Más de 500 plugins en el marketplace
• Los controladores personalizados te dan flexibilidad de backend a nivel Express.js
• Strapi Cloud ofrece una opción gestionada si no quieres autoalojar

Desventajas:

• El autoalojamiento requiere trabajo de operaciones —espera entre 10 y 20 horas al mes para actualizaciones, monitoreo y copias de seguridad
• Sin colaboración en tiempo real (dos editores pueden sobreescribir los cambios del otro)
• La migración de Strapi 4 a 5 tiene fricción: Entity Service a Document Service, nuevos formatos de respuesta, incompatibilidades entre plugins
• Strapi Cloud todavía está madurando comparado con las plataformas alojadas de Contentful o Sanity
• Menor adopción empresarial que Contentful —menos certificaciones de cumplimiento
• La personalización del panel de administración, aunque posible, requiere un conocimiento profundo de las APIs internas de Strapi

Cuándo NO usar Strapi:

• Si necesitas colaboración en tiempo real — ¿tu equipo editorial trabaja simultáneamente en el contenido? Usa Sanity. Strapi no tiene edición en tiempo real.
• Si necesitas gobernanza empresarial y SOC2 — ¿organización con fuertes requisitos de cumplimiento? Contentful lleva una década de ventaja en herramientas de gobernanza.
• Equipo no técnico sin soporte de desarrollador — Strapi requiere un desarrollador para la instalación, el despliegue y el mantenimiento. Si tu equipo son todos marketers, considera un CMS SaaS o WordPress.
• Arquitectura serverless-first — Strapi necesita un servidor persistente. Si estás construyendo completamente sobre edge functions y serverless, Sanity o Contentful encajan mejor.

Preguntas frecuentes

¿Qué es Strapi y cómo funciona?

Strapi es un CMS headless de código abierto construido sobre Node.js. Defines tipos de contenido a través de un constructor visual o código, y Strapi genera automáticamente endpoints de API REST y GraphQL. Las aplicaciones frontend obtienen el contenido como JSON de esos endpoints. El panel de administración ofrece una interfaz basada en React para que los editores gestionen las entradas sin escribir código.

¿Es Strapi gratuito?

Sí. Strapi Community Edition es gratuito y de código abierto bajo la licencia MIT. Puedes autoalojarlo en tu propio servidor sin límites de uso, sin restricciones de usuarios y sin límites de llamadas API. Strapi Cloud (la opción de alojamiento gestionado) tiene un nivel gratuito con 10.000 llamadas API al mes, con planes de pago desde $18/mes para límites más altos.

¿Cuál es la diferencia entre Strapi y Contentful?

Strapi es de código abierto y autoalojado, lo que te da acceso total al código y propiedad de los datos. Contentful es una plataforma SaaS propietaria con una gobernanza empresarial más sólida, certificaciones de cumplimiento y un conjunto de herramientas editoriales más amplio. Elige Strapi para control del código y flexibilidad presupuestaria. Elige Contentful para necesidades de cumplimiento empresarial y equipos editoriales más grandes que necesiten infraestructura gestionada.

¿Es Strapi adecuado para principiantes?

Strapi es amigable para principiantes si tienes conocimientos básicos de Node.js y JavaScript. El panel de administración y el Content-Type Builder son visuales e intuitivos —no se requiere código para modelar el contenido. El despliegue y la lógica de backend personalizada requieren experiencia como desarrollador. Para principiantes absolutos sin experiencia en programación, WordPress o un CMS SaaS totalmente gestionado serían puntos de partida más sencillos.

¿Qué base de datos usa Strapi?

Strapi admite PostgreSQL, MySQL, MariaDB y SQLite. Los proyectos nuevos usan SQLite por defecto para un desarrollo sin configuración. PostgreSQL es la recomendada para cargas de producción —es la base de datos más probada con Strapi y gestiona bien el acceso concurrente, las consultas complejas y los tipos de campo JSON. La conexión a la base de datos se configura en config/database.ts.

¿Cómo se despliega Strapi en producción?

Puedes desplegar Strapi en Strapi Cloud (alojamiento gestionado desde $18/mes) o autoalojarlo en plataformas como Railway, Render, DigitalOcean o AWS. El autoalojamiento requiere configurar un servidor Node.js, base de datos PostgreSQL, variables de entorno, almacenamiento de medios (S3 o Cloudinary) y un gestor de procesos como PM2. Ejecuta npm run build antes de desplegar para compilar el panel de administración.

¿Es Strapi mejor que WordPress?

Strapi y WordPress resuelven problemas diferentes. Strapi es un CMS headless que sirve APIs JSON a cualquier frontend —ideal para desarrolladores que construyen apps personalizadas, entrega de contenido multiplataforma o sitios con mucho JavaScript. WordPress es un CMS tradicional que renderiza páginas HTML —mejor para usuarios no técnicos que quieren temas, constructores de arrastrar y soltar, y un ecosistema de plugins enorme sin escribir código.

¿Cuáles son las desventajas de Strapi?

Las principales desventajas son la carga operativa del autoalojamiento (actualizaciones, monitoreo, copias de seguridad), la falta de colaboración en tiempo real para equipos editoriales, la fricción en la migración entre versiones principales (v4 a v5 requirió cambios en el código) y una oferta empresarial menos madura comparada con Contentful. Strapi Cloud soluciona la carga del alojamiento pero todavía está poniéndose al día en funcionalidades y disponibilidad global.

¿Puede Strapi gestionar aplicaciones a gran escala?

Sí. Strapi puede gestionar aplicaciones a gran escala con la infraestructura adecuada: PostgreSQL con connection pooling, escalado horizontal detrás de un balanceador de carga, CDN para los activos multimedia y Redis para el caché. Empresas como IBM, NASA y Toyota usan Strapi en producción. El cuello de botella suele ser el rendimiento de la base de datos y la configuración del alojamiento, no Strapi en sí.

¿Qué es Strapi Cloud y cuánto cuesta?

Strapi Cloud es la plataforma de alojamiento gestionado oficial para proyectos Strapi. Se encarga del provisionamiento del servidor, gestión de la base de datos, CDN y copias de seguridad automáticas. Los precios comienzan con un nivel gratuito (1 proyecto, 10K llamadas API/mes), luego Essential a $18/mes, Pro a $90/mes y Scale a $450/mes. Cada nivel aumenta los límites de llamadas API, los usuarios del equipo y la capacidad de almacenamiento.