Sí, puedes usar Astro con WordPress. WordPress se queda como CMS para editar el contenido y Astro construye la web pública consumiendo su API REST. Conservas el panel, pero no el tema ni el frontend de WordPress: las rutas, el diseño, el SEO y la publicación pasan a depender de Astro.
Esta separación puede reducir la superficie expuesta en la web pública cuando Astro genera archivos estáticos, pero no vuelve WordPress invulnerable. El panel, la API, los plugins y el alojamiento siguen necesitando protección, y un CMS comprometido puede introducir contenido malicioso en el siguiente build.
La conexión técnica es la parte fácil. Lo importante es decidir qué ocurre después de pulsar «Publicar», cómo se previsualiza un borrador, quién genera los metadatos y quién mantiene los dos sistemas.
Esta guía desarrolla una arquitectura y un ejemplo reproducible a partir de la documentación oficial. No es un caso de cliente ni una afirmación de que haya desplegado esta combinación en producción. La utilizo para explicar qué habría que resolver antes de recomendarla en un proyecto real.
Qué significa usar WordPress como CMS headless
En una instalación tradicional, WordPress gestiona el contenido y también genera la web que visita el usuario. El tema, las plantillas y muchos plugins intervienen en ese frontend.
En una arquitectura headless, las responsabilidades se separan:
| WordPress | Astro |
|---|---|
| Panel de edición, usuarios y permisos | Rutas y plantillas públicas |
| Entradas, páginas, categorías y medios | Componentes, estilos y responsive |
| Estados de borrador y publicación | Title, canonical, schema y sitemap |
| API de contenido | Build, despliegue y rendimiento del frontend |
Astro consulta los datos y decide cómo convertirlos en páginas. WordPress deja de controlar la presentación pública.
Esta distinción evita una expectativa frecuente: conectar ambos sistemas no transforma un tema de WordPress en componentes de Astro. Tampoco traslada automáticamente Elementor, shortcodes, formularios o bloques añadidos por plugins. Solo recibes los datos que expone la API y debes construir todo lo demás.
Si todavía estás eligiendo plataforma, la comparativa entre Astro y WordPress responde a esa decisión. Esta guía parte de un requisito más concreto: el equipo quiere conservar el panel de WordPress y desarrollar el frontend con Astro.
Cuándo tiene sentido combinar Astro y WordPress
Lo consideraría cuando se cumplen varias condiciones:
- Ya existe un WordPress con mucho contenido que conviene conservar.
- Las personas que publican conocen su panel y necesitan seguir usándolo.
- El frontend requiere un diseño o una arquitectura que se quiere controlar desde código.
- Hay alguien responsable de WordPress, de Astro y del enlace entre ambos.
- El presupuesto contempla previews, despliegues y mantenimiento, no solo la primera conexión.
No lo elegiría para añadir un panel por si acaso. Si publica una sola persona técnica y el contenido cambia poco, Markdown o MDX puede ser más sencillo. Si se empieza desde cero, también conviene comparar un CMS diseñado como headless, como explico en Astro con Sanity como alternativa a WordPress.
Tampoco es una forma de eliminar WordPress. La instalación sigue necesitando alojamiento, copias, actualizaciones, permisos y vigilancia de plugins. Has desacoplado el frontend, no la responsabilidad sobre el CMS.
Cómo obtener contenido de WordPress desde Astro
WordPress incluye una API REST en /wp-json/wp/v2/. Para contenido público como entradas publicadas no suele hacer falta autenticación.
La guía oficial de Astro para WordPress también contempla GraphQL mediante plugins como WPGraphQL. En este ejemplo utilizo REST porque ya forma parte de WordPress y permite explicar la integración sin añadir otra dependencia; GraphQL puede tener sentido si el proyecto necesita consultas más específicas y acepta mantener ese plugin.
Por ejemplo, esta dirección devuelve entradas:
https://cms.ejemplo.com/wp-json/wp/v2/postsAntes de escribir componentes, abre el endpoint y revisa la forma real de la respuesta. Las páginas están en /pages, los medios en /media y cada tipo de contenido personalizado solo aparecerá si se registró con show_in_rest: true.
Una función pequeña y tipada puede encargarse de obtener todas las entradas:
import { z } from 'astro/zod';
const WORDPRESS_URL = import.meta.env.WORDPRESS_URL;
const WordPressPostSchema = z.object({
id: z.number().int(),
slug: z.string().min(1),
date: z.string(),
modified: z.string(),
title: z.object({ rendered: z.string() }),
content: z.object({ rendered: z.string() }),
});
const WordPressPostsSchema = z.array(WordPressPostSchema);
export type WordPressPost = z.infer<typeof WordPressPostSchema>;
export async function getWordPressPosts(): Promise<WordPressPost[]> {
const posts: WordPressPost[] = [];
let page = 1;
while (true) {
const url = new URL('/wp-json/wp/v2/posts', WORDPRESS_URL);
url.searchParams.set('page', String(page));
url.searchParams.set('per_page', '100');
url.searchParams.set(
'_fields',
'id,slug,date,modified,title,content',
);
const response = await fetch(url);
if (!response.ok) {
throw new Error(`WordPress API returned ${response.status}`);
}
const pagePosts = WordPressPostsSchema.parse(await response.json());
posts.push(...pagePosts);
const totalPages = Number(
response.headers.get('X-WP-TotalPages') ?? 1,
);
if (page >= totalPages) return posts;
page += 1;
}
}El valor de WORDPRESS_URL sería la raíz del CMS, por ejemplo https://cms.ejemplo.com. El ejemplo solicita solo los campos necesarios mediante _fields. WordPress devuelve resultados paginados y expone el número total de páginas en X-WP-TotalPages; pedir una sola respuesta dejaría contenido fuera cuando haya más entradas que el límite configurado. La documentación de paginación fija un máximo de 100 elementos por petición.
Para autores, imagen destacada o términos puedes hacer más peticiones o utilizar _embed. Conviene medir el tamaño de la respuesta y no pedir relaciones que la página no utiliza. WordPress documenta _fields y _embed entre sus parámetros globales.
Cómo crear las rutas de las entradas en Astro
Si la web se genera de forma estática, getStaticPaths() puede convertir cada slug de WordPress en una URL de Astro:
---
import sanitizeHtml from 'sanitize-html';
import {
getWordPressPosts,
type WordPressPost,
} from '../../lib/wordpress';
export async function getStaticPaths() {
const posts = await getWordPressPosts();
return posts.map((post) => ({
params: { slug: post.slug },
props: { post },
}));
}
const { post } = Astro.props as { post: WordPressPost };
const title = sanitizeHtml(post.title.rendered, {
allowedTags: [],
allowedAttributes: {},
});
const content = sanitizeHtml(post.content.rendered, {
allowedTags: [
'p', 'h2', 'h3', 'h4', 'ul', 'ol', 'li', 'a',
'strong', 'em', 'blockquote', 'figure', 'figcaption',
'img', 'pre', 'code',
],
allowedAttributes: {
a: ['href', 'title'],
img: ['src', 'alt', 'width', 'height', 'loading'],
},
allowedSchemes: ['https', 'mailto'],
allowProtocolRelative: false,
});
---
<article>
<h1>{title}</h1>
<div set:html={content} />
</article>Es una base, no un componente listo para producción. El ejemplo utiliza sanitize-html como opción compatible con un build en servidor; habría que instalarlo, mantenerlo actualizado y probar su configuración. La directiva set:html inserta HTML sin escaparlo, por eso el contenido se sanea antes mediante una lista permitida. Esa lista debe ajustarse a los bloques reales del proyecto. No añadas iframe, style, atributos de evento ni clases de forma general solo para recuperar un diseño roto.
También necesitarás estilos para el HTML que genera Gutenberg. Clases de alineación, tablas, galerías, pies de foto y bloques incrustados no adoptan por arte de magia el diseño de Astro. Un contenido correcto en el editor puede romperse en la web pública si no pruebas los bloques admitidos.
Publicar en WordPress no actualiza una web estática por sí solo
Astro genera páginas estáticas por defecto. Si obtiene las entradas durante el build, la web contiene una copia de los datos de ese momento. Una publicación posterior en WordPress no aparecerá hasta ejecutar y desplegar otro build.
El flujo completo suele ser:
- El editor publica o actualiza en WordPress.
- WordPress envía un webhook al servicio de despliegue.
- El proveedor inicia el build de Astro.
- Astro consulta la API y genera las páginas nuevas.
- La publicación termina cuando el despliegue está disponible, no cuando WordPress guarda la entrada.
Ese retraso debe explicarse al equipo y el webhook debe protegerse. También conviene decidir qué pasa si la API de WordPress no responde durante el build: fallar y conservar el despliegue anterior suele ser más seguro que publicar una web incompleta.
La alternativa es el renderizado bajo demanda de Astro. Permite consultar WordPress en cada petición o aplicar caché, pero necesita un adaptador y un runtime. A cambio de contenido más inmediato, introduces disponibilidad del servidor, latencia, estrategia de caché y coste operativo. No hay una opción universal: hay que elegir entre frescura, simplicidad y dependencia del CMS.
Los borradores y la vista previa necesitan otro flujo
La API pública devuelve contenido publicado. Mostrar borradores, revisiones o campos protegidos requiere autenticación y una ruta de preview que no se indexe.
WordPress admite Application Passwords sobre HTTPS para acceso remoto. Las credenciales deben permanecer en el servidor o en el entorno de build, nunca en código enviado al navegador.
Una preview completa debe resolver, como mínimo:
- Quién puede abrirla y cuánto dura el acceso.
- Cómo se identifica la revisión o el borrador solicitado.
- Qué plantilla de Astro lo representa.
- Cómo se evita que Google indexe esa URL.
- Qué bloques y campos se comportan igual que en producción.
Si nadie necesita previsualizar, puedes evitar parte de este trabajo. Si un equipo editorial lo considera imprescindible, no debería aparecer como una sorpresa después de desarrollar la integración.
Cómo asegurar Astro con WordPress headless
No existe una configuración que garantice que esta arquitectura no será vulnerable. El objetivo razonable es reducir entradas innecesarias, limitar el daño de una cuenta o plugin comprometido y detectar fallos antes de que lleguen a la web pública.
Astro estático evita ejecutar PHP y plugins de WordPress en cada visita, pero WordPress sigue conectado a internet. Además, el build confía en lo que devuelve su API. Si alguien compromete el CMS y consigue publicar HTML malicioso, Astro puede convertirlo en una página estática perfectamente válida.
| Riesgo | Medida principal |
|---|---|
| WordPress o un plugin desactualizado | Actualizaciones, menos plugins y copias restaurables. |
| Cuenta editorial comprometida | Roles mínimos, contraseña fuerte y segundo factor. |
| Credencial de API filtrada | Secreto de servidor, usuario dedicado y rotación. |
HTML malicioso en content.rendered |
Validación de datos y saneado mediante una lista permitida. |
| Webhook de despliegue falsificado | Firma o secreto verificable, HTTPS y límites de frecuencia. |
| Preview descubierta por terceros | Autenticación, autorización y caducidad; noindex no protege el acceso. |
| WordPress caído o respuestas enormes | Timeout, límite de tamaño, caché y conservación del último despliegue válido. |
WordPress sigue siendo una aplicación que hay que proteger
Una instalación headless debe mantenerse igual que cualquier otro WordPress expuesto. La guía oficial de hardening de WordPress recomienda mantener core y plugins actualizados, utilizar software de fuentes fiables, limitar permisos, desactivar la edición de archivos desde el panel cuando no se necesite y conservar copias que realmente puedan restaurarse.
También aplicaría estas decisiones:
- Separar el CMS en un origen como
cms.ejemplo.compara definir mejor cookies, cabeceras y responsabilidades. El subdominio no es una defensa por sí mismo. - Eliminar plugins y temas que no aportan nada al CMS headless. Cada extensión añade código que actualizar y revisar.
- Dar a cada persona el rol mínimo que necesita. Quien redacta no debería poder instalar plugins o editar PHP.
- Proteger las cuentas con segundo factor y reservar las cuentas administradoras para tareas administrativas.
- Mantener HTTPS en el panel, la API y cualquier webhook. Ocultar la URL de acceso puede reducir ruido automático, pero no sustituye estos controles.
La API pública tampoco es un fallo por el hecho de poder leerse. Las entradas ya publicadas son públicas. Lo importante es que borradores, campos privados y operaciones de escritura sigan exigiendo autenticación y autorización, y que la respuesta no incluya datos que el frontend no necesita.
Las credenciales solo deben existir en el servidor
Para leer publicaciones públicas no enviaría ninguna credencial. Para previews u operaciones protegidas usaría una Application Password independiente y revocable, asociada a un usuario dedicado con los permisos mínimos. No reutilizaría la contraseña principal de una cuenta administradora.
El secreto debe vivir en el entorno de build o servidor. Astro distingue variables públicas de secretos de servidor y deja claro que no existe una variable secreta segura en el cliente. Por tanto:
- No uses prefijos o módulos de entorno públicos para la contraseña.
- No realices peticiones autenticadas desde un componente enviado al navegador.
- No escribas credenciales, cabeceras
Authorizationni URLs secretas de despliegue en logs. - Revoca y sustituye una credencial si se ha expuesto o deja de utilizarse.
Una URL difícil de adivinar y una etiqueta noindex no protegen una preview. La ruta debe comprobar una sesión o token firmado, autorizar el contenido solicitado y caducar el acceso. noindex solo habla con buscadores; no impide que otra persona abra la página.
TypeScript no valida la API y set:html no sanea el contenido
Una interfaz de TypeScript describe lo que esperas recibir, pero desaparece al ejecutar el código. Por eso el ejemplo anterior usa un esquema de Zod antes de aceptar la respuesta. En producción añadiría también límites de tamaño, timeout y tratamiento explícito de errores.
La segunda frontera es el HTML de WordPress. OWASP recomienda sanear el HTML cuando debe conservarse su formato, en lugar de insertarlo directamente. El ejemplo utiliza una lista pequeña de etiquetas y atributos. Si Gutenberg necesita una clase, un iframe o un atributo adicional, se revisa y se incorpora de forma concreta; no se abre todo el HTML para que el diseño funcione.
El saneado debe ocurrir antes de set:html, durante el build o en el servidor. También hay que mantener actualizada la librería utilizada y no volver a modificar la cadena saneada de una forma que reintroduzca código peligroso. Incluso el contenido escrito por administradores merece esta defensa: una cuenta o un plugin pueden verse comprometidos.
Protege el webhook y limita el impacto de los fallos
Un endpoint que inicia despliegues no debe aceptar cualquier petición. Si el proveedor ofrece una URL de despliegue secreta, se trata como una credencial y se rota si se filtra. En una integración propia, la guía de seguridad de webhooks de OWASP recomienda HTTPS, firmas verificables como HMAC, protección frente a reintentos o replay, límites de tamaño y frecuencia, y logs sin secretos.
Con generación estática, un fallo de WordPress debería cancelar el build y conservar la versión publicada anterior. Con renderizado bajo demanda, WordPress pasa a formar parte de cada petición: además de validar y sanear, necesitas timeout, caché, límites de respuesta y una estrategia cuando el CMS no esté disponible.
Finalmente aplicaría cabeceras en el frontend de Astro. Una CSP puede limitar scripts, conexiones, imágenes e iframes, pero OWASP la considera una capa adicional, no la defensa principal contra XSS. img-src debe contemplar el dominio de medios de WordPress; connect-src solo necesita la API si el navegador la consulta directamente. La guía sobre cabeceras de seguridad para una web desarrolla esa configuración y sus límites.
Antes de publicar comprobaría como mínimo:
- Actualizaciones, roles, segundo factor, permisos de archivos y restauración de backups en WordPress.
- Solo los endpoints y campos necesarios, sin credenciales para contenido público.
- Secretos de preview y despliegue fuera del cliente, del repositorio y de los logs.
- Validación de la respuesta y saneado del HTML antes de renderizarlo.
- Webhooks autenticados, limitados y probados con firmas incorrectas y reintentos.
- Preview protegida por autorización real y con caducidad.
- Cabeceras y CSP verificadas sobre la respuesta desplegada de Astro.
- Monitorización de accesos, builds fallidos, cambios inesperados y versiones pendientes.
Quién controla el SEO en una arquitectura headless
La web pública es Astro, así que Astro debe generar title, descripción, canonical, Open Graph, schema, sitemap y enlaces hreflang. Instalar un plugin SEO en WordPress no configura automáticamente el <head> del frontend desacoplado.
Puedes exponer campos SEO por la API y mapearlos en Astro, pero hay que decidir cuáles son la fuente de verdad. Duplicar títulos en WordPress y en el repositorio sin una regla clara acaba produciendo inconsistencias.
También debes elegir una sola versión pública de cada contenido. Si la entrada puede visitarse en WordPress y en Astro, existen dos URLs con información igual o muy parecida. Lo habitual es impedir que el frontend de WordPress compita con Astro y declarar canonicals coherentes. Google explica que redirecciones y rel="canonical" son señales fuertes para consolidar URLs duplicadas.
Si Astro sustituye URLs antiguas de WordPress, prepara una correspondencia uno a uno, redirecciones permanentes y un sitemap nuevo. La guía de migración de Google recomienda probar el mapeo, actualizar las canonicals y mantener las redirecciones durante el tiempo suficiente. La guía para migrar de WordPress a Astro desarrolla esa parte sin mezclarla con la conexión headless.
Qué mantenimiento añade esta arquitectura
Astro y WordPress juntos pueden resolver un requisito real, pero no forman un sistema más simple que cualquiera de los dos por separado. Hay que mantener:
- WordPress, PHP, base de datos, usuarios y plugins.
- El proyecto Astro, sus dependencias y el despliegue.
- El contrato entre la API y los tipos de TypeScript.
- Webhooks, variables de entorno y credenciales.
- Bloques admitidos, previews, imágenes y metadatos.
- Alertas para builds fallidos y contenido desactualizado.
Un cambio de campo, plugin o estructura puede romper el frontend aunque WordPress siga funcionando. Por eso el alcance debería incluir pruebas sobre contenido real y un responsable posterior. Correcciones, actualizaciones y mejoras también deben quedar separadas dentro del mantenimiento.
Mi criterio para elegirlo
Usaría WordPress headless con Astro cuando conservar el panel sea un requisito demostrado y el control del frontend compense mantener la integración. No lo elegiría solo porque la combinación sea técnicamente posible.
En este portfolio utilizo colecciones de contenido y MDX porque soy quien publica, versiono los cambios con el código y no necesito un panel separado. En otro proyecto, un equipo editorial acostumbrado a WordPress podría justificar una decisión distinta.
La pregunta final no es «¿se pueden conectar?». Es esta:
¿Qué flujo permite que la persona responsable publique, previsualice y mantenga el contenido sin introducir más complejidad de la que el proyecto puede asumir?
Si estás definiendo una web profesional y el panel de edición es un requisito, conviene decidirlo antes de cerrar arquitectura y presupuesto. En mi servicio de diseño y desarrollo web explico el alcance base y cómo planteo el mantenimiento; una integración con CMS se valoraría según el contenido, las personas que publican y el flujo necesario.