PageKit: el creador de sitios GrapesJS autoalojado, con el código fuente incluido. Obtener acceso anticipado

Constructor de páginas drag-and-drop

Crea un constructor de páginas drag-and-drop con GrapesJS

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.

Código abiertoAutoalojadoExtensiblePersonalizable

26k+

Estrellas en GitHub

1.4M+

Descargas mensuales en npm

100+

Plugins en GJS.Market

BSD-3-Clause

Licencia del core

Pruébalo

Prueba el editor drag-and-drop

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.

Publica páginas, no tickets

Haz clic en este texto y escribe encima.

Lo que incluye

Tres columnas en escritorio, una en móvil.

El editor de verdad

…y este es GrapesJS en persona

Tres builds públicos de GrapesJS que solo se cargan cuando tú lo pides: hasta entonces no se descarga nada.

Abrir en una pestaña nueva

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.

grapesjs.com/demo.htmlGratis

Carga una demo de terceros en un iframe. No se solicita nada hasta que haces clic.

El ciclo

Arrastra. Suelta. Diseña. Publica.

Una página, de principio a fin

  1. Elige un bloque
  2. Arrástralo al lienzo
  3. Personalízalo
  4. Previsualiza
  5. Guarda
  6. Publica
Capacidades

Lo que el editor ya hace

Seis subsistemas que vienen con el core y que tus usuarios perciben como un solo gesto.

Drag & drop

Mueve bloques y componentes directamente al lienzo, y reordénalos una vez colocados.

Edición visual

Edita contenido y estilos sobre la propia página: tipografía, espaciado, color y fondo, sin tocar una hoja de estilos.

Diseño responsive

Adapta los diseños a distintos tamaños de pantalla con el gestor de dispositivos y los breakpoints del editor.

Componentes reutilizables

Construye secciones una vez y reutilízalas en varias páginas: un cambio en un sitio llega a todas.

Recursos

Gestiona imágenes y otros archivos desde el gestor de recursos, apuntando al almacenamiento que ya uses.

Publicación

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ú.

Por qué GrapesJS

¿Por qué construir tu editor con GrapesJS?

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.

Código abierto

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.

Autoalojado

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.

Extensible

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.

Personalizable

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.

Tu backend

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.

Ecosistema de plugins

Amplía el editor con plugins de GJS.Market y npm en lugar de escribir cada capacidad desde cero.

Casos de uso

¿Qué puedes construir?

El mismo núcleo debajo, configurado cada vez para un trabajo distinto.

Para quién es

¿Quién necesita un constructor drag-and-drop?

Motivos distintos para quererlo, pero debajo el mismo problema: crear páginas no debería exigir un desarrollador cada vez.

Equipos SaaS

Añade la creación de páginas como función de producto, sin que el cliente salga de tu app.

Plataformas web

Construye tu propia experiencia de edición visual en lugar de revender la de otro.

Desarrolladores de CMS

Pon una capa visual encima del modelo de contenido que ya tienes.

Agencias

Crea sistemas de construcción de páginas que los clientes puedan manejar entre proyecto y proyecto.

Equipos de producto

Reduce la cola de cambios rutinarios de maquetación y textos que hoy acaban en ingeniería.

Desarrolladores

Empieza desde un núcleo de editor extensible, no desde un lienzo en blanco y una librería de drag-and-drop.

Construir o partir de un núcleo

¿Construir un editor desde cero?

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 del editor
  • Drag & drop
  • Bloques
  • Componentes
  • Gestor de estilos
  • Controles responsive
  • Recursos
  • Páginas
  • Almacenamiento
  • Deshacer / rehacer
  • Exportación
  • Publicación
  • Mantenimiento
Desde cero

Todos ellos son tuyos

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.

Con GrapesJS

Empiezas donde eso ya funciona

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.

Cara a cara

Lo que te toca en cada caso

Ninguna de las dos columnas sale gratis. La diferencia está en qué trabajo es tuyo.

SubsistemaDesde ceroCon GrapesJS
Lienzo del editorDiseñarlo y construirloViene en el core
Drag & dropZonas de destino, indicadores, reglas de anidamientoViene en el core
BloquesDefinir el formato y la UI del panelBlock Manager, más plugins de bloques ya hechos
ComponentesCrear un modelo de componentes y sus propiedadesTipos de componente con traits y comportamiento propio
Gestor de estilosConstruir un editor visual de CSSEn el core, con sectores configurables
Controles responsiveEstado de breakpoints en todo el editorDevice Manager, ampliable con plugins
RecursosBiblioteca, flujo de subida, selectorAsset Manager, apuntando a tu almacenamiento
PáginasEstado multipágina y navegaciónPage Manager
AlmacenamientoFormato de serialización y endpointsStorage Manager contra tu API
Deshacer / rehacerUna pila de comandos sobre cada mutaciónViene en el core
ExportaciónGeneración de HTML/CSSgetHtml() / getCss(), más plugins de exportación
PublicaciónTuyaTuya, y a propósito
Mantenimiento del editorTuyoCompartido 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.

Arquitectura

Cómo encaja un constructor drag-and-drop en tu producto

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

  • Usuarios
  • Auth y permisos
  • Plantillas
  • Rutas
  • Facturación

Capa embebida

Editor GrapesJS

Amplíalo con plugins
  • Lienzo
  • Bloques
  • Componentes
  • Gestor de estilos
  • Recursos
  • Páginas
  • Persistencia

    Tu API

    • Storage Manager
    • Autoguardado
    • Versiones
  • Datos

    Tu base de datos

    • Proyectos
    • Páginas
    • Recursos
  • Entrega

    Tu publicación

    • Vista previa
    • Publicar
    • Sitio en vivo
GrapesJS aporta la capa de edición visual, mientras tu aplicación sigue controlando usuarios, contenido, almacenamiento y 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

Responsive

Crea páginas responsive de forma visual

El Device Manager del editor cambia el lienzo entre breakpoints, y los estilos aplicados con un dispositivo activo solo valen para ese ancho.

Escritorio1440px
Tableta768px
Móvil375px

Lo que se puede cambiar por breakpoint

  • Diseño y columnas
  • Espaciado
  • Tipografía
  • Visibilidad
  • Alineación
  • Fondo

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.

Bloques

Empieza con bloques ya hechos

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.

  • Portada

    Titular, texto de apoyo y una acción principal.

  • Cabecera

    Logo y navegación, que colapsa a menú en pantallas pequeñas.

  • Ventajas

    Un juego de columnas con icono, título y texto.

  • Precios

    Tarjetas de plan con una destacada como recomendada.

  • Testimonios

    Citas con autoría y avatar.

  • Galería

    Una cuadrícula de imágenes servida desde el gestor de recursos.

  • Llamada a la acción

    Una sola llamada a la acción, centrada.

  • Contacto

    Un formulario conectado al endpoint que elijas.

  • Pie de página

    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.

Bloques y componentes

Los bloques son lo que se arrastra. Los componentes, en lo que se convierten.

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.

  1. Bloque
  2. Componente
  3. Componente propio
  4. Tu producto

Bloque

El punto de partida

Una entrada del panel. Arrastrarla al lienzo inserta contenido: el bloque en sí no es lo que queda en la página.

Componente

El elemento editable

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

Lo defines tú

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.

Plantillas

No empieces con un lienzo en blanco

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

  • SaaS
  • Startup
  • Agencia
  • Empresa
  • Portafolio
  • Landing
  • Ecommerce

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.

Almacenamiento

Tus páginas, en tu propia base de datos

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

  1. Editor
  2. Datos del proyecto
  3. Tu API
  4. Tu base de datos
Almacenamiento remoto y publicaciónJS
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.

Publicación

Tú controlas cómo se publican las páginas

  1. 1
    Editar

    El usuario construye la página

    Arrastra, suelta, edita y da estilo en el lienzo. El autoguardado mantiene recuperable el trabajo en curso.

  2. 2
    Borrador

    Persistir a través de tu API

    El Storage Manager envía el proyecto a tu endpoint. Todavía no hay nada publicado.

  3. 3
    Vista previa

    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.

  4. 4
    Publicar

    Tu flujo, tus reglas

    Aprobaciones, programación, versionado: lo que tu producto ya haga. GrapesJS no participa en este paso.

  5. 5
    En vivo

    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.

Ecosistema de plugins

Amplía tu constructor con plugins de GJS.Market

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.

Combinaciones

Monta el constructor que necesitas

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.

Los precios se renderizan en vivo desde el catálogo.

Primeros pasos

Empieza a construir tu editor de páginas

Dos archivos y ya tienes un editor en pantalla. Todo lo que viene después es configuración.

npm install grapesjs
editor.jsJS
import 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:

blocks.jsJS
// 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'],
    },
  },
});
  1. Añade bloques
  2. Personaliza componentes
  3. Configura el almacenamiento
  4. Conecta tu backend
  5. Publica

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.

Frameworks

Usa GrapesJS con tu stack

El core es agnóstico al framework: se monta sobre un contenedor del DOM. Estas páginas cubren el cableado de cada caso.

Comparativa

GrapesJS frente a otros constructores

Solo 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ísticaGrapesJSPuckCraft.jsBuilder.io
Código abiertoSí — BSD-3-ClauseSí — MITSí — MITSDK con MIT; plataforma propietaria
AutoalojadoServicio alojado
FrameworkAgnóstico; con wrapper de React disponibleReactReactSDK para varios frameworks
Bloques propiosSí — Block ManagerSí — configuración de componentesSí — componentes de usuarioSí — componentes registrados
Componentes propiosSí — tipos de componente con traitsSí — componentes React con camposSí — componentes React con ajustesSí — con inputs
Interfaz propia del editorSí — paneles reemplazables, o gobernarlo sin UIUI incluida, con temasLa pones tú — no incluye UIUI del proveedor
Backend de almacenamiento propioSí — Storage Manager contra tu APISí — la persistencia es tuyaSí — el estado lo persistes túEl contenido se guarda en Builder.io
Publicación propiaA través de las APIs de Builder.io
Ecosistema de pluginsSí — GJS.Market y npmEn crecimientoPequeñoIntegraciones 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.

Relacionado

Soluciones relacionadas

El mismo núcleo, otra pregunta. Si alguna de estas encaja mejor con tu situación, empieza por ahí.

Preguntas frecuentes

Dudas sobre constructores drag-and-drop

Empieza

Construye tu propio constructor drag-and-drop

Empieza con GrapesJS, personaliza la experiencia de edición y amplíala con los plugins que tu producto necesite.

Marketplace

Ver plugins para constructores

Bloques, plantillas, almacenamiento, recursos, exportación e IA: artículos reales con precios reales.

Ver plugins para constructores
Gratis

Empezar a construir

Instala el core, monta el editor y registra tu primer bloque. Sin registros de por medio.

Empezar a construir
Servicios

¿Necesitas desarrollo a medida?

Componentes propios, interfaz del editor, integración con tu backend: cuéntanos qué tiene que hacer el constructor.

¿Necesitas desarrollo a medida?