Publica páginas, no tickets
Haz clic en este texto y escribe encima.
PageKit: el creador de sitios GrapesJS autoalojado, con el código fuente incluido. Obtener acceso anticipado
Ofrece a tus usuarios un editor visual para construir páginas web con componentes drag-and-drop, bloques reutilizables y estilos responsive, sin montar la infraestructura del editor desde cero.
26k+
Estrellas en GitHub
1.4M+
Descargas mensuales en npm
100+
Plugins en GJS.Market
BSD-3-Clause
Licencia del core
Arrastra un bloque desde el panel hasta el lienzo, o toca un bloque y luego el lienzo. Edita el texto sobre la marcha, ajusta el espaciado y el radio, y cambia de viewport para ver cómo se adapta el diseño. Esto es un modelo de la interacción; el editor real de GrapesJS está en la sección siguiente.
Bloques
Arrastra un bloque, o toca un bloque y luego el lienzo.
Haz clic en este texto y escribe encima.
Tres columnas en escritorio, una en móvil.
Estilos
Color
Tres builds públicos de GrapesJS que solo se cargan cuando tú lo pides: hasta entonces no se descarga nada.
La demo estándar de GrapesJS: panel de bloques a la derecha, lienzo en el centro, gestor de estilos y árbol de capas. Todo lo que ves aquí está en el core de código abierto.
Carga una demo de terceros en un iframe. No se solicita nada hasta que haces clic.
Una página, de principio a fin
Seis subsistemas que vienen con el core y que tus usuarios perciben como un solo gesto.
Mueve bloques y componentes directamente al lienzo, y reordénalos una vez colocados.
Edita contenido y estilos sobre la propia página: tipografía, espaciado, color y fondo, sin tocar una hoja de estilos.
Adapta los diseños a distintos tamaños de pantalla con el gestor de dispositivos y los breakpoints del editor.
Construye secciones una vez y reutilízalas en varias páginas: un cambio en un sitio llega a todas.
Gestiona imágenes y otros archivos desde el gestor de recursos, apuntando al almacenamiento que ya uses.
Conecta el editor a tu propio flujo de publicación: GrapesJS te entrega HTML y CSS, y tú decides qué pasa después.
Cada uno de estos puntos es un subsistema que, de otro modo, tendrías que diseñar, construir y mantener tú.
GrapesJS es un framework de editor autoalojado y de código abierto, no un producto de construcción de webs alojado. Esa distinción es justamente lo que le permite vivir dentro de la aplicación de otra persona.
Parte de una base de editor abierta. El core se publica como BSD-3-Clause y el wrapper oficial de React como MIT: ambos permiten uso comercial y no hay cuota de licencia.
El editor corre dentro de tu propia infraestructura. No hay un proveedor de editor entre tú y tus usuarios, y nada sale de tu stack salvo que tú lo envíes.
Crea bloques, tipos de componente, comandos y paneles propios. La API de plugins es la misma contra la que están escritos los plugins del ecosistema.
Sustituye paneles, rediseña el envoltorio o gobierna el editor por completo desde tu propia interfaz. La UI no es fija, y las demos de arriba lo demuestran.
El gestor de almacenamiento habla con tus endpoints. Proyectos, páginas, recursos y usuarios se quedan en tu base de datos, tras tu propia autenticación.
Amplía el editor con plugins de GJS.Market y npm en lugar de escribir cada capacidad desde cero.
El mismo núcleo debajo, configurado cada vez para un trabajo distinto.
Deja que tus usuarios creen landings orientadas a conversión a partir de un juego de bloques curado.
Constructor de landingsConstruye sitios completos de varias páginas con diseños reutilizables y navegación compartida.
Editor WYSIWYGDa a tus clientes creación visual de páginas como una función más dentro de tu aplicación.
Constructor para SaaSAñade una capa de edición visual sobre un flujo de contenidos existente en lugar de sustituirlo.
Editor para CMS headlessDeja que marketing monte y actualice páginas sin abrir una pull request.
No-code para desarrolladoresOfrece creación de páginas controlada: los bloques que tú permitas, dentro del marco que tú definas.
Editor de marca blancaMotivos distintos para quererlo, pero debajo el mismo problema: crear páginas no debería exigir un desarrollador cada vez.
Añade la creación de páginas como función de producto, sin que el cliente salga de tu app.
Construye tu propia experiencia de edición visual en lugar de revender la de otro.
Pon una capa visual encima del modelo de contenido que ya tienes.
Crea sistemas de construcción de páginas que los clientes puedan manejar entre proyecto y proyecto.
Reduce la cola de cambios rutinarios de maquetación y textos que hoy acaban en ingeniería.
Empieza desde un núcleo de editor extensible, no desde un lienzo en blanco y una librería de drag-and-drop.
Un constructor de páginas no es una funcionalidad: es una docena de subsistemas que tienen que encajar entre sí, y seguir encajando a medida que el producto crece.
Lo que contiene realmente un constructor de páginas
Lienzo, zonas de destino, selección, panel de estilos, breakpoints, biblioteca de recursos, estado multipágina, persistencia, una pila de deshacer que sobreviva a todo eso, exportación, publicación… y el mantenimiento de todo el conjunto.
El editor visual, el drag & drop, los bloques, los componentes, el gestor de estilos, los recursos, las páginas, las APIs de almacenamiento y el sistema de plugins vienen con el core. Lo que añades es lo específico de tu producto.
Construye tu producto, no otro editor de páginas desde cero.
Ninguna de las dos columnas sale gratis. La diferencia está en qué trabajo es tuyo.
| Subsistema | Desde cero | Con GrapesJS |
|---|---|---|
| Lienzo del editor | Diseñarlo y construirlo | Viene en el core |
| Drag & drop | Zonas de destino, indicadores, reglas de anidamiento | Viene en el core |
| Bloques | Definir el formato y la UI del panel | Block Manager, más plugins de bloques ya hechos |
| Componentes | Crear un modelo de componentes y sus propiedades | Tipos de componente con traits y comportamiento propio |
| Gestor de estilos | Construir un editor visual de CSS | En el core, con sectores configurables |
| Controles responsive | Estado de breakpoints en todo el editor | Device Manager, ampliable con plugins |
| Recursos | Biblioteca, flujo de subida, selector | Asset Manager, apuntando a tu almacenamiento |
| Páginas | Estado multipágina y navegación | Page Manager |
| Almacenamiento | Formato de serialización y endpoints | Storage Manager contra tu API |
| Deshacer / rehacer | Una pila de comandos sobre cada mutación | Viene en el core |
| Exportación | Generación de HTML/CSS | getHtml() / getCss(), más plugins de exportación |
| Publicación | Tuya | Tuya, y a propósito |
| Mantenimiento del editor | Tuyo | Compartido con un proyecto de código abierto y su ecosistema |
La publicación se queda en tu columna a propósito: es la parte que tiene que encajar con tus dominios, tu CDN y tu proceso de release.
GrapesJS es una capa dentro de tu aplicación, no una plataforma a la que entregas tus usuarios. Tu app conserva los usuarios, el contenido y la decisión de publicar.
Tu aplicación
La superficie es tuya
Capa embebida
Editor GrapesJS
Amplíalo con pluginsPersistencia
Tu API
Datos
Tu base de datos
Entrega
Tu publicación
Para la mecánica de montar el editor dentro de una app existente —iframes, rutas, traspaso de sesión— consulta la guía del editor embebible
El Device Manager del editor cambia el lienzo entre breakpoints, y los estilos aplicados con un dispositivo activo solo valen para ese ancho.
Lo que se puede cambiar por breakpoint
Deja que tus usuarios adapten diseño, espaciado, tipografía y visibilidad a cada tamaño de pantalla. Cómo se vea al final una página publicada en un dispositivo concreto sigue dependiendo del HTML y el CSS que entregues: el editor controla las reglas, no el navegador.
Un bloque es el punto de partida que el usuario arrastra. Estos son los tipos de sección que casi cualquier constructor necesita el primer día: constrúyelos tú contra la API del Block Manager, o instala un plugin de bloques y arranca con el panel lleno.
Titular, texto de apoyo y una acción principal.
Logo y navegación, que colapsa a menú en pantallas pequeñas.
Un juego de columnas con icono, título y texto.
Tarjetas de plan con una destacada como recomendada.
Citas con autoría y avatar.
Una cuadrícula de imágenes servida desde el gestor de recursos.
Una sola llamada a la acción, centrada.
Un formulario conectado al endpoint que elijas.
Columnas de enlaces, avisos legales y navegación secundaria.
Son tipos de bloque, no productos. Los plugins de bloques que sí están a la venta aparecen más abajo.
Esta distinción decide si GrapesJS te parece un juguete para hacer webs o un núcleo de editor sobre el que construir un producto.
Bloque
Una entrada del panel. Arrastrarla al lienzo inserta contenido: el bloque en sí no es lo que queda en la página.
Componente
En lo que se convierte el bloque al soltarlo. Los componentes tienen tipo, traits y reglas sobre qué se puede anidar, arrastrar o eliminar.
Componente propio
Registra tu propio tipo de componente y el editor lo tratará como uno más: tus traits, tu barra de herramientas, tus restricciones y tus datos detrás.
Como los componentes propios están respaldados por tu código, un editor GrapesJS puede editar cosas que un constructor genérico ni siquiera concibe: una tabla de precios conectada a tus planes, una parrilla que lee tu catálogo, un formulario que envía a tu API.
Casi nadie quiere una página vacía. Ofrece un juego de diseños de partida y deja que guarden los suyos: los presets configuran el editor entero, las plantillas dan una página por la que empezar.
Los diseños que suelen pedir los usuarios
Son categorías de diseño, no artículos del catálogo: lo que construirías o curarías para tus propios usuarios. Los presets y gestores de plantillas que sí puedes instalar están en la sección de plugins.
El Storage Manager es un cliente de tu API, no un servicio. Apúntalo a tus endpoints y el editor cargará y guardará a través de ellos.
A dónde van los datos
const editor = grapesjs.init({
container: '#editor',
// Each page is a row in your database, behind your own auth.
storageManager: {
type: 'remote',
autosave: true,
options: {
remote: {
urlStore: `/api/pages/${pageId}`,
urlLoad: `/api/pages/${pageId}`,
fetchOptions: { credentials: 'include' },
},
},
},
});
// Publishing stays on your side — your domains, your CDN, your workflow.
async function publish() {
await fetch(`/api/pages/${pageId}/publish`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ html: editor.getHtml(), css: editor.getCss() }),
});
}Conecta GrapesJS a tu propio backend y decide cómo se guardan proyectos, páginas, recursos y usuarios. GJS.Market vende plugins: no aloja tus datos.
El usuario construye la página
Arrastra, suelta, edita y da estilo en el lienzo. El autoguardado mantiene recuperable el trabajo en curso.
Persistir a través de tu API
El Storage Manager envía el proyecto a tu endpoint. Todavía no hay nada publicado.
Renderízala como la verán
Exporta HTML y CSS y muestra la vista previa en una ruta a la que solo llegue el autor.
Tu flujo, tus reglas
Aprobaciones, programación, versionado: lo que tu producto ya haga. GrapesJS no participa en este paso.
Servida desde tu infraestructura
Tus dominios, tu CDN, tu caché. La página es HTML y CSS corrientes.
GrapesJS se encarga de la experiencia de edición. Tu aplicación controla el flujo de publicación.
Cada tarjeta de aquí abajo es un artículo real: nombres, precios y miniaturas se renderizan en vivo desde el catálogo, así que nada de esta página puede desviarse de lo que está realmente a la venta.
El juego básico de primitivas de maquetación —columnas, texto, imágenes, enlaces— para que el panel no esté vacío el primer día.
Una biblioteca de bloques basada en Tailwind, para equipos cuyo sistema de diseño ya habla en clases utilitarias.
Un indicador de destino más claro, para que se vea exactamente dónde va a caer el bloque antes de soltarlo.
Tiradores para ajustar márgenes y relleno arrastrando, de modo que el espaciado se define en el lienzo y no en un campo numérico.
Construye secciones una vez y reutilízalas en varias páginas.
Ver esta categoríaPersiste proyectos en Firebase cuando prefieres no montar antes un endpoint de almacenamiento.
Guarda una copia recuperable del trabajo en curso, para que cerrar una pestaña no le cueste la página al usuario.
Cuatro configuraciones de partida. Cada una es una cesta real de artículos, no un pack cerrado: instala lo que necesites y deja el resto.
Para páginas de marketing que tienen que convertir
Para sitios de varias páginas con diseños compartidos
Editor WYSIWYGPara crear páginas dentro de tu producto
Para una capa visual sobre contenido existente
Los precios se renderizan en vivo desde el catálogo.
Dos archivos y ya tienes un editor en pantalla. Todo lo que viene después es configuración.
npm install grapesjsimport grapesjs from 'grapesjs';
import 'grapesjs/dist/css/grapes.min.css';
// The editor core. Mount it on any container in your app.
const editor = grapesjs.init({
container: '#editor',
});Después define qué pueden arrastrar tus usuarios, y en qué se convierte al soltarlo:
// A block is what the user drags. A component is what it becomes
// on the canvas once dropped — and what your app can then control.
editor.BlockManager.add('pricing-table', {
label: 'Pricing',
category: 'Sections',
content: { type: 'pricing-table' },
});
editor.DomComponents.addType('pricing-table', {
model: {
defaults: {
// Lock the frame, let the user edit only what you allow.
draggable: 'main, section',
traits: ['plan', 'currency'],
},
},
});A partir de aquí el trabajo es específico de tu producto: qué bloques reciben tus usuarios, qué tipos de componente registras y dónde se guardan los proyectos.
El core es agnóstico al framework: se monta sobre un contenedor del DOM. Estas páginas cubren el cableado de cada caso.
Sin framework alguno: importa el core, móntalo en un contenedor y listo.
Constructor HTML drag-and-dropEl wrapper oficial @grapesjs/react (MIT) se encarga del montaje y la limpieza.
GrapesJS con ReactMontaje solo en cliente, import dinámico y los escollos de SSR que conviene evitar.
Constructor con Next.jsMóntalo dentro de un componente y limpia al desmontar.
GrapesJS con VueEnvuelve el editor en un componente y mantenlo fuera de la detección de cambios.
GrapesJS con AngularSolo características que pueden comprobarse contra el paquete publicado y la documentación de cada proyecto. Las capacidades difieren por diseño: Craft.js es headless a propósito, Puck va primero con React y Builder.io es una plataforma alojada.
| Característica | GrapesJS | Puck | Craft.js | Builder.io |
|---|---|---|---|---|
| Código abierto | Sí — BSD-3-Clause | Sí — MIT | Sí — MIT | SDK con MIT; plataforma propietaria |
| Autoalojado | Sí | Sí | Sí | Servicio alojado |
| Framework | Agnóstico; con wrapper de React disponible | React | React | SDK para varios frameworks |
| Bloques propios | Sí — Block Manager | Sí — configuración de componentes | Sí — componentes de usuario | Sí — componentes registrados |
| Componentes propios | Sí — tipos de componente con traits | Sí — componentes React con campos | Sí — componentes React con ajustes | Sí — con inputs |
| Interfaz propia del editor | Sí — paneles reemplazables, o gobernarlo sin UI | UI incluida, con temas | La pones tú — no incluye UI | UI del proveedor |
| Backend de almacenamiento propio | Sí — Storage Manager contra tu API | Sí — la persistencia es tuya | Sí — el estado lo persistes tú | El contenido se guarda en Builder.io |
| Publicación propia | Sí | Sí | Sí | A través de las APIs de Builder.io |
| Ecosistema de plugins | Sí — GJS.Market y npm | En crecimiento | Pequeño | Integraciones del proveedor |
Licencias verificadas contra el registro de npm el 2026-09-03: grapesjs 0.23.6 se publica como BSD-3-Clause; @measured/puck, @craftjs/core y @builder.io/react se publican como MIT. Las capacidades reflejan la documentación pública de cada proyecto: compruébalas antes de decidir.
El mismo núcleo, otra pregunta. Si alguna de estas encaja mejor con tu situación, empieza por ahí.
El caso de negocio de añadir un constructor a un SaaS: qué gana el cliente y cómo se empaqueta.
Constructor para SaaSEl recorrido técnico para montar el editor dentro de una aplicación existente.
Editor embebibleMarca, temas y multi-tenancy cuando el editor tiene que parecer tuyo.
Editor de marca blancaEl panorama completo de licencias y autoalojamiento.
Editor de código abiertoEmpieza con GrapesJS, personaliza la experiencia de edición y amplíala con los plugins que tu producto necesite.
Bloques, plantillas, almacenamiento, recursos, exportación e IA: artículos reales con precios reales.
Ver plugins para constructoresInstala el core, monta el editor y registra tu primer bloque. Sin registros de por medio.
Empezar a construirComponentes propios, interfaz del editor, integración con tu backend: cuéntanos qué tiene que hacer el constructor.
¿Necesitas desarrollo a medida?Más sobre cómo construir editores con GrapesJS: