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

Creador de páginas de aterrizaje

Constructor de Landing Pages con GrapesJS

Crea un creador de páginas de aterrizaje visual con arrastrar y soltar con secciones reutilizables, edición responsiva, componentes personalizados, formularios, controles SEO y tu propio flujo de trabajo de publicación.

Editor visual de arrastrar y soltarBloques y componentes personalizadosSalida HTML y CSSAutoalojadoExtensible con plugins
your-app.com/pages/spring-launch
GrapesJS
EscritorioTabletaMóvil

Bloques

  • Hero
  • Características
  • Logotipos
  • Precios
  • FAQ
  • CTA
  • Formulario

Capas

  • Hero
  • Características
  • Testimonios
  • Precios
  • FAQ
  • CTA

Estilos

  • Espaciado
  • Tipografía
  • Fondo
Una página de aterrizaje compuesta por secciones reutilizables, dentro de un editor que posees. Los paneles son los que te da GrapesJS; la biblioteca de secciones es la parte que defines tú.
Pruébalo

Crear páginas de destino visualmente

Empieza desde un lienzo en blanco o una plantilla, arrastra secciones a su lugar, personaliza estilos y contenido, y publica desde tu propia aplicación. Arrastra un bloque al lienzo de abajo — o toca un bloque y luego toca el lienzo — para ver el gesto que harán tus usuarios.

Secciones

Arrastra una sección dentro — o toca una sección, y luego toca el lienzo.

Lanzar la campaña de primavera

Haz clic en este texto y escribe encima.

Tres razones por las que convierte

Corto, escaneable, con el beneficio primero.

Fijación simple

Tres niveles, uno recomendado.

Lo real

… y aquí está el propio GrapesJS

Tres builds públicas de GrapesJS, cargadas solo cuando pides una: nada se recupera hasta que haces clic.

Abrir en una pestaña nueva

La demo de GrapesJS de serie: paleta de bloques, lienzo, gestor de estilos y árbol de capas. Todo lo visible aquí viene en el núcleo de código abierto.

grapesjs.com/demo.htmlGratis

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

Idea central

Construye el editor. No construyas el motor de editores.

Un creador de páginas de aterrizaje parece una sola función y se comporta como una docena. Antes de que un marketer pueda arrastrar una sección hero a su sitio, alguien tiene que haber construido un lienzo, un modelo de componentes, un sistema de arrastrar y soltar, un gestor de estilo, edición responsiva, deshacer, gestión de activos y un formato de serialización — y luego mantener todo funcionando.

Opción A

Hazlo desde cero

Diseña primero la arquitectura del editor, luego lanza el producto.

Implementas y mantienes

  • Modelo de lienzo y documento
  • Arrastrar y soltar, incluyendo el tacto
  • Árbol de componentes y traits
  • Biblioteca de bloques y categorías
  • Gestor de capas
  • Estilo de gestión y reglas CSS
  • Conmutación de dispositivo responsiva
  • Historia de deshacer / rehacer
  • Gestor de activos
  • Serialización y almacenamiento
  • Arquitectura de comandos y plugins

Cada uno de esos es un subsistema con sus propios casos límite, y ninguno es lo que tus clientes pagan.

Opción B

Empieza desde GrapesJS

Toma el motor de edición tal y como te lo has dado y personalízalo.

Ya está en el núcleo de código abierto

  • Modelo de lienzo y componentes
  • Arrastrar y soltar
  • Bloques API
  • Gestor de capas
  • Responsable de estilo
  • Administrador de dispositivos
  • Deshacer / volver a hacer
  • Gestor de activos
  • Serialización por proyecto
  • Mandos
  • Arquitectura de plugins

Configuras los paneles, registras tus propias secciones y gastas tu presupuesto de ingeniería en el producto en su lugar.

Mira el inicio rápido
Opción C

Extender con plugins

Añade los textos específicos de marketing sin escribirlos.

Instalado en lugar de construido

  • Bibliotecas de secciones de página de aterrizaje
  • Plantillas y gestores de páginas
  • Componentes de forma
  • SEO y auditoría de accesibilidad
  • Etiquetas de analítica
  • Canalizaciones de activos y adaptadores de almacenamiento
  • Objetivos de publicación y exportación

Instala, configura, personaliza, envia — y guarda el código de tu equipo para las piezas que nadie más puede montar para ti.

Explorar plugins

GrapesJS te da la base de edición visual para que tu equipo pueda centrarse en el producto que lo rodea.

Alcance

De qué está hecho realmente un creador de páginas de aterrizaje

Diecinueve subsistemas, etiquetados por quién acaba siendo el propietario de cada uno. La cuestión no es que la lista sea larga, sino que solo los últimos cuatro son específicos de tu negocio.

  • LienzoNúcleo GrapesJS
  • Arrastrar y soltarNúcleo GrapesJS
  • ComponentesNúcleo GrapesJS
  • BloquesNúcleo GrapesJS
  • CapasNúcleo GrapesJS
  • Responsable de estiloNúcleo GrapesJS
  • Edición responsivaNúcleo GrapesJS
  • Deshacer / volver a hacerNúcleo GrapesJS
  • ActivosNúcleo GrapesJS
  • SerializaciónNúcleo GrapesJS
  • MandosNúcleo GrapesJS
  • Arquitectura de pluginsNúcleo GrapesJS
  • Biblioteca de seccionesPlugins
  • PlantillasPlugins
  • Componentes de formaPlugins
  • Controles SEOTu aplicación
  • PublicaciónTu aplicación
  • AnalíticaTu aplicación
  • ExperimentosTu aplicación
¿Quién lo construye?Tu aplicaciónNúcleo GrapesJSPlugins

GrapesJS cubre el motor de edición. Los plugins cubren las superficies específicas de la página de inicio. Todo en la última línea es donde tu producto realmente difiere del resto.

Definición

¿Qué es un creador de páginas de aterrizaje?

Un creador de páginas de aterrizaje es un editor visual que permite a los usuarios crear páginas de campaña sin tener que escribir a mano cada elemento HTML y la regla CSS.

No es una sola función. Un creador de páginas de destino es un editor más bloques, plantillas, formularios, SEO, análisis, experimentos y publicación — y cada uno de esos es una decisión sobre quién posee qué.

En la práctica, se espera que un creador moderno de páginas de aterrizaje ofrezca todo lo siguiente:

Lo que los equipos esperan de uno

  • Edición de arrastrar y soltar
  • Secciones reutilizables
  • Plantillas
  • Edición responsiva
  • Componentes personalizados
  • Formularios
  • Controles SEO
  • Gestión de activos
  • Publicación
  • Analítica
  • Experimentos

Edición visual, no edición de código

El usuario manipula directamente la página renderizada. Un generador de páginas de aterrizaje de arrastrar y soltar convierte el diseño en un gesto en lugar de una solicitud de fusión.

Secciones, no elementos

Los profesionales del marketing piensan en héroes, tablas de precios y preguntas frecuentes. Un editor de páginas de destino construido en torno a bloques de sección coincide con la forma en que realmente se planifican las campañas.

HTML y CSS los quedas

La salida es marcado que controlas y puedes renderizar en cualquier lugar — no un formato propietario bloqueado a un entorno de ejecución alojado.

GrapesJS proporciona la capa de edición visual. Tu aplicación controla el backend, los datos, la autenticación y el flujo de trabajo de publicación.

Aplicaciones

¿Qué se puede construir con un creador de páginas de destino?

El mismo motor de edición visual respalda productos muy diferentes. Lo que cambia es la aplicación que lo rodea: quién inicia sesión, qué puede hacer y dónde acaba la página.

Arquitectura

Cómo funciona un creador de páginas de aterrizaje

Hay una línea que importa en este diagrama, y se sitúa entre el editor y tu API. Todo lo que está encima es una preocupación de autoría. Todo lo que está debajo es tu producto.

Tu aplicación

  • Autenticación
  • Usuarios
  • Proyectos
  • Permisos
  • Base de datos
  • Facturación
  • Analítica
  • Publicación

Datos del proyecto

GrapesJS

  • Canvas
  • Components
  • Blocks
  • Layers
  • Styles
  • Assets
  • Commands

De la creación a la página en vivo

  1. Usuario
  2. Editor visual
  3. GrapesJS
  4. Datos del proyecto
  5. Tu API
  6. Base de datos
  7. Publicar
  8. Página de aterrizaje en directo
El editor nunca habla directamente con tu base de datos. Te entrega los datos del proyecto; tu API decide qué significa eso, quién puede guardarlo y qué ocurre al publicar.
  • El editor es una herramienta de autoría del lado del cliente. Trata cada guardado como una entrada no confiable que llega a tu API.
  • Los datos del proyecto son la fuente de verdad desde la que reabres el editor; HTML y CSS son el renderizado de ellos.
  • Vista previa y publicación son dos rutas sobre los mismos datos, no dos formatos de almacenamiento.

GrapesJS es el propietario de la superficie de edición. Tu aplicación es dueña de la identidad, los datos y la entrega. Mantener esa línea limpia es lo que hace que el constructor sea reemplazable, probable y tuyo.

Capacidades

Todo lo que necesitas para la edición visual de la página de aterrizaje

Estas son las capacidades de edición que ofrece GrapesJS de fábrica, y las que su plugin API está diseñado para ampliar.

Arrastrar y soltar

Construye los diseños visualmente. Los componentes se retiran, se reordenan y anidan en el propio lienzo.

Bloques reutilizables

Registra tus propias secciones y componentes una vez; cada usuario arrastra la misma librería.

Edición responsiva

Cambia de dispositivo en el editor y escribe las reglas por punto de interrupción. El conjunto de dispositivos por defecto es escritorio, tableta, horizontal móvil y vertical móvil.

Componentes personalizados

Define los tipos de componentes con su propio traits y comportamiento para que el editor coincida con el sistema de diseño de tu producto.

Gestión de activos

Gestiona imágenes y otros medios a través del gestor de activos, respaldado por el almacenamiento que ya uses.

Responsable de estilo

Controla la tipografía, el espaciado, los colores y la disposición mediante controles agrupados por sectores que puedes configurar.

Plantillas

Inicia campañas desde diseños reutilizables en lugar de un lienzo en blanco, a través de los plugins de plantilla en el catálogo.

HTML & CSS

getHtml() y getCss() devuelven el marcado que el lienzo renderizado, así que la salida publicada sigue siendo tuya para optimizar.

Flujo de trabajo

De un lienzo en blanco a una campaña publicada

  1. 1
    Paso 1

    Elige una plantilla

    Abre un diseño guardado en lugar de una página en blanco. La campaña más rápida es aquella que empieza con un 70% de finalización.

  2. 2
    Paso 2

    Añadir secciones

    Arrastra hero, características, precios, testimonios y bloques FAQ en el orden que la campaña necesite.

  3. 3
    Paso 3

    Personalizar contenido

    Edita el texto en el lienzo, cambia imágenes a través del gestor de activos y establece enlaces.

  4. 4
    Paso 4

    Ajustar estilos responsivos

    Cambia de dispositivo y arregla la disposición por punto de interrupción antes de que alguien lo vea en un móvil.

  5. 5
    Paso 5

    Añadir formularios

    Deja el formulario de captura y apúntalo a tu propio punto final.

  6. 6
    Paso 6

    Vista previa

    Renderiza la página desde los datos del proyecto en una ruta de vista previa — el mismo renderizador que funciona a la página en vivo.

  7. 7
    Paso 7

    Publicar

    Escribe el HTML, CSS y el registro SEO, asigna el slug y sírvelo desde tu propia infraestructura.

Crea una vez. Reutiliza entre campañas.

Biblioteca de bloques

Crear una biblioteca de bloques de páginas de destino reutilizables

El núcleo de GrapesJS no lleva bloques. Eso no es una omisión — es el punto de extensión. La biblioteca de bloques que registras es exactamente lo que convierte un editor visual genérico en un creador de páginas de aterrizaje diseñado específicamente, y es el código de mayor palanca que escribirás.

  • Hero

    Titular, subtítulo y la llamada principal a la acción.

  • Características

    Dos o cuatro columnas de beneficios con iconos.

  • Nube de logotipos

    Logotipos de clientes o de integración como prueba social.

  • Testimonios

    Citas, nombres y avatares cerca del punto de conversión.

  • Precios

    Planes escalonados con una columna de recomendaciones.

  • Comparación

    Tabla de características frente a la alternativa que el visitante está valorando.

  • FAQ

    Gestión de objeciones, en palabras del propio visitante.

  • Formulario de contacto

    La superficie de captación de leads, publicando en tu API.

  • Boletín

    Suscribirse a campo único, para el visitante que aún no esté preparado.

  • Llamada a la acción

    La pregunta repetida, al final de la página.

  • Pie de página

    Señales de navegación, legales y de fideicomiso.

Inicio rápido

Las primeras veinte líneas

Instala el núcleo, móntalo y registra las secciones que lo convierten en un generador de páginas de destino. Todo lo demás en esta página es una decisión superpuesta a estas líneas.

Instalación

npm install grapesjs
page-builder.tsTS
import grapesjs from 'grapesjs';
import 'grapesjs/dist/css/grapes.min.css';

const editor = grapesjs.init({
  container: '#editor',
  height: '100vh',
  // The core ships no blocks at all — the section library below is what
  // turns a generic visual editor into a *landing page* builder.
  blockManager: { appendTo: '#blocks' },
  storageManager: false,
});

const SECTIONS = [
  { id: 'hero',     label: 'Hero',         html: '<section class="hero">…</section>' },
  { id: 'features', label: 'Features',     html: '<section class="features">…</section>' },
  { id: 'logos',    label: 'Logo cloud',   html: '<section class="logos">…</section>' },
  { id: 'pricing',  label: 'Pricing',      html: '<section class="pricing">…</section>' },
  { id: 'faq',      label: 'FAQ',          html: '<section class="faq">…</section>' },
  { id: 'cta',      label: 'Call to action', html: '<section class="cta">…</section>' },
];

SECTIONS.forEach(({ id, label, html }) => {
  editor.Blocks.add(id, { label, category: 'Landing page', content: html });
});

Cada bloque es una etiqueta, una categoría y un fragmento de marcado. Si le das al marcado un tipo de componente, también recibe traits, restricciones y su propia barra de herramientas.

Plantillas

Empieza con las plantillas de página de destino

Una plantilla es un proyecto guardado que abre un usuario en lugar de un lienzo en blanco. Las categorías que aparecen a continuación son los tipos de diseño que piden los equipos de marketing — los plugins que hay debajo son los que permiten a tus usuarios guardar, gestionar y volver a abrirlos.

Tipos de distribución que los equipos solicitan

  • SaaS
  • Inicio
  • Producto
  • Agencia
  • Evento
  • App
  • Boletín
  • Seminario web

Estos son tipos de maquetación, no listados de catálogo: no hay un tipo de producto plantilla en GJS.Market. Los gestores de plantillas y páginas que aparecen a continuación son plugins reales que le dan a tu creador un sitio donde guardarlos.

Captación de leads

Convierte las páginas de aterrizaje en páginas de generación de leads

Una página de destino sin superficie de captura es un folleto. El componente de formulario es una preocupación del editor; todo lo que viene después del botón de enviar es tuyo.

Ruta de envío

  1. Página de aterrizaje
  2. Formulario
  3. Envío
  4. Tu API
  5. CRM / base de datos
Mantén tu backend y el CRM bajo tu control. Una página publicada que publica directamente a un tercero les entrega tus datos del embudo junto con el lead.

Enruta cada envío a través de tu propio endpoint. Ahí es donde pertenecen la validación, la limitación de tasas, el manejo de spam, el consentimiento y el enrutamiento CRM — y ninguno de ellos es algo que debería decidir un editor de páginas.

api/leads.tsTS
// The form component is editor-side. The submission is yours.
// Never let the published page post straight to a third party you do not
// control — route it through your own endpoint so you keep the lead.

app.post('/api/leads', async (req, res) => {
  const parsed = leadSchema.safeParse(req.body);     // validate server-side
  if (!parsed.success) return res.status(422).json({ error: 'invalid' });

  await rateLimit(req.ip);                            // forms get abused
  const lead = await db.leads.create({
    data: { ...parsed.data, pageSlug: req.body.pageSlug, utm: pickUtm(req.body) },
  });

  await crm.upsertContact(lead);                      // your CRM, your rules
  res.json({ ok: true });
});

Formularios de contacto

Nombre, correo electrónico del trabajo, mensaje. La ruta de ventas predeterminada en una página de campaña B2B.

Formularios de boletín

Campo único, baja fricción, para visitantes interesados pero no preparados.

Formularios de inscripción

Directamente al producto, con los parámetros de campaña cumplidos.

Formularios de cualificación de leads

Tamaño de la empresa, rol, presupuesto: las necesidades de ventas del campo antes de la primera llamada.

Búsqueda

Dota a cada landing page de sus propios controles SEO

Una página de campaña que un profesional del marketing no puede titular, describir o canonizar sin un desarrollador no está terminada. GrapesJS edita el cuerpo del documento; el encabezado pertenece a tu aplicación, así que el registro SEO debe formar parte del modelo de tu página desde el principio.

SEO de páginas

Título
<title>
Spring Launch — Acme
Meta descripción
meta[name=description]
Ship campaign pages without a developer…
URL canónica
link[rel=canonical]
https://acme.com/spring
Open Graph
meta[property^=og:]
og:title, og:description, og:type
Imagen social
og:image
/og/spring-launch.png
Robots
meta[name=robots]
index, follow
Datos estructurados
application/ld+json
{ "@type": "WebPage" }

Almacenado junto a los datos del proyecto, editado en la misma pantalla, emitido por tu renderizador al publicar.

Trata los metadatos de SEO como un campo de primera en el registro de la página, no como algo añadido tras el lanzamiento. Los profesionales del marketing deberían poder cambiar un título sin abrir una solicitud pull.

page-seo.tsTS
// SEO belongs to your application, not to the canvas.
// Keep the marketing metadata beside the project data, so a marketer can
// edit it in the same screen and your renderer can emit it on publish.

type LandingPage = {
  slug: string;
  project: unknown;        // editor.getProjectData()
  seo: {
    title: string;
    description: string;
    canonical?: string;
    ogImage?: string;
    robots?: 'index,follow' | 'noindex,nofollow';
    jsonLd?: Record<string, unknown>;
  };
};

// On publish, your renderer — not GrapesJS — writes the <head>.
function renderHead(page: LandingPage) {
  return [
    `<title>${escapeHtml(page.seo.title)}</title>`,
    `<meta name="description" content="${escapeHtml(page.seo.description)}">`,
    page.seo.canonical && `<link rel="canonical" href="${page.seo.canonical}">`,
    page.seo.robots && `<meta name="robots" content="${page.seo.robots}">`,
  ].filter(Boolean).join('\n');
}
Experimentos

Construir → publicar → Medida → Mejorar

Un generador de páginas de destino se vuelve mucho más valioso cuando los equipos pueden iterar en campañas en lugar de tratar las páginas como activos estáticos. Una vez que una página es un dato en lugar de un archivo, una variante es barata: es otra fila de proyecto que apunta al mismo slug.

  1. Editor

    Construcción

    Duplica la página en el editor y cambia una cosa: el titular, la oferta, la longitud del formulario.

  2. Tu aplicación

    Publicar

    Ambas variantes publican en el mismo slug, con los pesos que decida tu aplicación.

  3. Tu aplicación

    Medida

    Asigna un visitante una vez, continúa la tarea y reporta la tarea junto con tus eventos de conversión.

  4. Tu aplicación

    Mejorar

    Promociona al ganador al valor por defecto y comienza la siguiente prueba desde ahí.

  1. Tráfico
    • Variante A
    • Variante B
  2. Conversiones
  3. Ganador

La asignación, el ponderado y la importancia son lógica de aplicación. GrapesJS no está involucrado más allá del punto en que se crearon las dos variantes — por eso mismo puede mantenerse fuera de la ruta de servicio.

No hay ningún plugin de pruebas A/B en el catálogo de GJS.Market, y GrapesJS no tiene función de experimentación. Este es un patrón para implementar en tu aplicación, no un producto para instalar — y un generador de páginas es lo que lo hace barato.

render-page.tsTS
// A/B testing is an application concern, not an editor feature.
// A landing page builder makes it cheap because a variant is just
// another project row pointing at the same slug.

const variants = await db.pageVariants.findMany({
  where: { slug, status: 'running' },
});

// Assign once, persist the choice, and report it to your analytics.
const variant = pickWeighted(variants, hash(visitorId));
res.setHeader('Set-Cookie', `exp_${slug}=${variant.id}; Path=/; Max-Age=2592000`);
res.setHeader('Vary', 'Cookie');   // or the page will be cached for everyone

return renderPublishedPage(variant);
Medición

Conecta tus páginas de destino con tu pila de analítica

No necesitas construir una plataforma de analítica dentro de tu creador de páginas. Necesitas páginas publicadas para emitir los eventos que tu pila existente ya entiende.

Eventos de análisis

Disparad a las interacciones que importan: envíos de formularios, clics en CTA, profundidad de desplazamiento en páginas largas.

Seguimiento de conversiones

Vincula una propuesta a la página, la variante y la campaña que la produjo.

Visitas a páginas

La línea base cada dos números es una proporción de.

Parámetros de campaña

Conserva los valores UTM desde el primer clic hasta el registro CRM.

Integraciones externas

Envía el contenedor o etiqueta que ya usa tu equipo en lugar de inventar una capa de informes.

Utiliza tu propia infraestructura de analítica. El trabajo del creador es asegurarse de que cada página publicada lleve las etiquetas y parámetros correctos sin que un profesional del marketing tenga que recordarlos.

Salida

Tus páginas de destino. Tu pila.

El editor produce dos cosas: datos de proyecto desde los que los reabres, y HTML más CSS que sirves. Ambos son tuyos, en formatos que puedes leer.

  1. GrapesJSCódigo abierto
  2. Datos del proyectoSalida
  3. HTML + CSSSalida
  4. Tu backendTuyo
  5. Tu hosting / CDNTuyo
Código abierto

GrapesJS

El motor de edición. Autoalojado, con licencia BSD-3-Clause, sin servicio alojado en la ruta.

Salida

Datos del proyecto

El JSON en el que se almacenan tus páginas. Legible, difusible y es tuyo para migrar.

Salida

HTML + CSS

Lo que devuelven getHtml() y getCss() — el marcado exacto que mostró el lienzo.

Tuyo

Tu backend

Autenticación, versionado, permisos y el endpoint de publicación. La parte que realmente es tu producto.

Tuyo

Tu hosting / CDN

Desde donde se sirven las páginas publicadas, según tus propios términos de rendimiento y caché.

Mantén el control de los datos de tu proyecto, HTML/CSS y la infraestructura de publicación. El autoalojamiento no garantiza que la migración sea gratuita — sigues siendo dueño de la integración que escribiste — pero sí significa que nada de lo que construyas está detrás del botón de exportación de otra persona.

Construir vs adoptar

¿Crear un creador de páginas de aterrizaje desde cero o usar GrapesJS?

Las mismas catorce capacidades, leídas dos veces. A la izquierda, cada fila es un proyecto. A la derecha, la mayoría son configuraciones — y las tres que no lo son están etiquetadas honestamente.

CapacidadDesde ceroGrapesJS
LienzoLo construyes túIncluido
Arrastrar y soltarLo construyes túIncluido
ComponentesLo construyes túIncluido
BloquesLo construyes túExtensible
EstiloLo construyes túIncluido
Edición responsivaLo construyes túIncluido
ActivosLo construyes túExtensible
AlmacenamientoLo construyes túExtensible
PlantillasLo construyes túExtensible
Arquitectura de pluginsLo construyes túIncluido
FormulariosLo construyes túExtensible
Controles SEOLo construyes túIntegra con tu stack
Pruebas A/BLo construyes túIntegra con tu stack
PublicaciónLo construyes túIntegra con tu stack

Verificado en comparación con la documentación de GrapesJS y el catálogo GJS.Market en 2026-09-03. "Extensible" significa que hay un API y plugins existentes para él; "Integrar" significa que el editor deliberadamente no lo hace y que tu aplicación debería hacerlo.

Usa GrapesJS para el motor de edición. Usa tu propia aplicación para todo lo específico de tu negocio.

Plugins

Construye tu pila de constructores de páginas de destino

Listados reales del catálogo GJS.Market, agrupados por las cuatro áreas de capacidad desde las que se ensambla un creador de páginas de aterrizaje. Los precios y la disponibilidad se leen del catálogo en el momento de la compilación.

Comisariado

Elige los plugins que tu build realmente necesite

Tres listas de la compra, enmarcadas por lo que estás construyendo en lugar de por categoría de catálogo.

Los precios se leen del catálogo en el momento de la compilación y pueden haber cambiado: la página del producto es autorizada.

Dos caminos

Empieza por el núcleo. Añade lo que necesites.

GrapesJS proporciona la base de edición visual. Los plugins de GJS.Market te permiten añadir capacidades especializadas sin tener que construir cada función tú mismo.

Camino A

Construye todo tú mismo

Cada capacidad se convierte en un ticket, una revisión y un compromiso de mantenimiento.

  1. Más ingeniería
  2. Más mantenimiento
  3. Más código interno para poseer
  4. Un camino más largo hasta la primera página publicada
Camino B

Extender con plugins

Cuatro pasos, repetidos por capacidad, sobre un motor que no escribiste.

  1. Instalación
  2. Configurar
  3. Personalizar
  4. Buque
Caso de uso

Crea un creador de páginas de aterrizaje SaaS

Poner un creador de páginas dentro de un producto no es mayormente un problema de editor. El editor es una vía; el resto es la maquinaria multiinquilino que lo rodea.

Dónde encaja el editor

  1. Tu aplicación
  2. Autenticación
  3. Organizaciones
  4. Proyectos
  5. Editor GrapesJS
  6. Almacenamiento de proyectos
  7. Publicación

Usuarios y equipos

Quién puede abrir el editor y a quién ve las páginas cuando lo hace.

Proyectos

La unidad a la que pertenece una página. Normalmente la misma unidad que facturas.

Permisos

Editar, publicar y eliminar son tres derechos diferentes. La publicación es la que merece la pena proteger.

Facturación

Número de páginas, número de asientos o volumen de publicación — todo lo cual el editor está encantado de no saberlo.

Marca blanca

Tu Chrome, tus fuentes, tus iconos. El editor UI es configuración, no una interfaz fija.

Publicación

Slugs, dominios personalizados, versiones y rollbacks, servidos desde tu infraestructura.

El editor es una sola pantalla en tu producto. La tenancia, los permisos y la facturación son lo que lo convierte en una función que puedes vender.

Caso de uso

Crea un generador de páginas de aterrizaje de marca blanca para agencias

El problema de una agencia no es construir un solo creador de páginas. No es reconstruir lo mismo para el undécimo cliente.

Imagen de la agencia

O del cliente. El editor Chrome, los iconos y la tipografía son tuyos para configurar por inquilino.

Bloques reutilizables

Una biblioteca de secciones, mantenida una vez, desplegada en cada cuenta.

Proyectos de clientes

Proyectos aislados bajo una sola instalación, con activos y plantillas por cliente.

Plantillas

Lanza un cliente nuevo con los diseños que funcionaron para el anterior.

Permisos

Deja que un cliente edite el texto sin que reestructuren la página o publiquen sin revisar.

Publicación

Despliega en el dominio y alojamiento del cliente, sin que la agencia se convierta en una empresa de alojamiento.

Crea un sistema de edición y reutilízalo en varios proyectos del cliente. Los bloques y plantillas se convierten en el activo de la agencia; el cliente solo ve su propia marca.

Licencias

¿Por qué usar un generador de páginas de destino de código abierto?

El núcleo GrapesJS se publica bajo la licencia BSD-3-Clause y el envoltorio oficial de React bajo MIT. Ambos permiten el uso comercial. Las consecuencias prácticas:

Autoalojamiento

El editor se ejecuta dentro de tu aplicación. No hay ningún servicio de editor alojado entre tú y tus usuarios.

Personalización

Los paneles, comandos y tipos de componentes son todos reemplazables, no solo temizables.

Control sobre los datos

Los datos del proyecto permanecen en tu base de datos, en un formato que puedes leer y migrar.

UI personalizado

Construye la interfaz del editor que necesiten tus usuarios en lugar de la que lanza un proveedor.

Integraciones personalizadas

Tu CRM, tu almacenamiento de activos, tu destino de despliegue — conectados por cable a través del plugin API.

Extensibilidad

Una arquitectura de plugins documentada y un catálogo existente para apoyarse.

No dependía de editores propietarios

Nada de lo que construyas depende de que un editor alojado siga existiendo en sus términos actuales.

Rendimiento

Consideraciones de rendimiento

Un constructor de páginas tiene dos presupuestos de rendimiento muy diferentes, y confundirlos es el error más común en esta arquitectura.

  • Carga perezosamente el editor

    Importala dinámicamente para que nunca acabe en un paquete compartido.

  • Inicializar solo cuando sea necesario

    Una instancia del editor, en la ruta de autoría, se montaba en el lado del cliente.

  • Evitar re-renderizados innecesarios

    El editor posee su propio DOM. Volver a renderizar el envoltorio en cada pulsación de tecla lo pone en problemas.

  • Optimizar grandes bibliotecas de activos

    Paginar y cargar perezosamente el gestor de activos en vez de listar cada subida.

  • Plugins con cargas perezosas

    Carga un plugin cuando se abra el panel que lo necesita, no en la entrada del editor.

  • Editores separados y tiempos de ejecución públicos

    Dos puntos de entrada, dos presupuestos. La página publicada no debería importar al editor en absoluto.

  • Optimizar páginas publicadas de forma independiente

    Imágenes, fuentes y CSS crítico en la salida, ajustados como cualquier otra página de producción.

editor-route.tsxTSX
// The editor is an authoring environment. Keep it out of the bundle
// that a visitor downloads to read a published landing page.

// /admin/editor — loaded only for authenticated authors.
const PageBuilder = dynamic(() => import('@/components/page-builder'), {
  ssr: false,                       // GrapesJS measures the DOM on init
  loading: () => <EditorSkeleton />,
});

// Heavy, optional plugins load when the panel that needs them opens.
async function openAssetManager(editor) {
  const { default: cloudinary } = await import('grapesjs-cloudinary');
  cloudinary(editor, { cloudName: process.env.NEXT_PUBLIC_CLOUDINARY });
  editor.runCommand('open-assets');
}

El editor es un entorno de autoría. Las páginas de destino publicadas no necesitan necesariamente todo el tiempo de ejecución del editor — y una página de campaña que envíe un paquete de editor a cada visitante ha descartado la razón para crear una.

Seguridad

Consideraciones de seguridad

Un generador visual acepta entradas estructuradas de un navegador y las convierte en un marcado que sirves. Cada elemento que aparece a continuación se deduce de esa única frase.

  • Autenticar el APIs

    Los endpoints de cargar, guardar y publicar son privilegiados. Trátalos así.

  • Validar permisos por acción

    Poder editar una página no es lo mismo que poder publicarla.

  • Validar los activos subidos

    Comprueba el tipo, tamaño y contenido del lado del servidor, y muestra las subidas de usuario desde un origen que estés dispuesto a aislar.

  • Limpiar el contenido generado por los usuarios

    Cuando no se confíe plenamente en los autores de páginas, desinfecta tanto al salir como al entrar.

  • Validar los datos del proyecto

    Que el proyecto JSON llegue a tu API es una entrada no confiable. Analiza, no simplemente la almacenes.

  • Proteger el endpoint de publicación

    La publicación cambia lo que ve el público. Limita la tarifa, regístrala y hazla revertible.

  • Nunca confíes en el estado del lado del cliente

    Todo lo que envíe el editor puede ser falsificado. Vuelve a obtener la propiedad y los límites del servidor.

Esto es una lista de comprobación inicial, no una garantía. Modela tu propio despliegue de amenazas — especialmente si las personas que editan las páginas no son las propietarias del dominio.

Alcance

Empieza poco a poco. Escala hasta convertirte en una plataforma completa de página de aterrizaje.

Tres etapas, cada una enviable. El error es intentar llegar a la tercera antes de que alguien haya publicado una página de la primera.

  1. 1Etapa 1

    MVP

    Una persona puede crear y publicar una página.

    • Editor visual
    • Bloques básicos
    • Plantillas
    • Almacenamiento sencillo
    • Publicación
    Mira el inicio rápido
  2. 2Etapa 2

    Producción

    Un equipo puede confiar en ello sin que tú estés en la sala.

    • Autenticación
    • Proyectos
    • Gestión de activos
    • Componentes personalizados
    • Permisos
    • Versión
    • SEO
    • Formularios
    Explorar plugins
  3. 3Etapa 3

    Plataforma de marketing

    El constructor se convierte en algo que puedes vender.

    • Pruebas A/B
    • Analítica
    • Biblioteca de plantillas
    • Gestión de campañas
    • Equipos
    • Marca blanca
    • Facturación
    Creador de páginas SaaS

Cada etapa después de la primera es una decisión de producto, no de editora — por eso mismo el editor no debería ser lo que aún estás construyendo.

FAQ

Preguntas Comunes

¿Qué es un creador de páginas de aterrizaje?

Un creador de páginas de aterrizaje es un editor visual para crear páginas de campaña sin escribir a mano HTML y CSS. En la práctica, combina un lienzo de arrastrar y soltar, una biblioteca de secciones reutilizable, plantillas, edición responsiva, formularios, controles SEO y un paso de publicación.

¿Puedo crear un creador de páginas de aterrizaje con GrapesJS?

Sí. GrapesJS es un framework para crear editores visuales más que un producto terminado, así que proporciona el lienzo, el modelo de componentes, arrastrar y soltar, el gestor de estilos, el árbol de capas, el gestor de activos y la arquitectura de plugins, y tú construyes las partes específicas de la página de inicio encima: tu biblioteca de secciones, plantillas y la aplicación que las rodea.

¿Es GrapesJS un creador de páginas de destino de código abierto?

GrapesJS es de código abierto: el núcleo se publica bajo la licencia BSD-3-Clause y el envoltorio oficial de React bajo MIT. Ambos permiten el uso comercial. Es una biblioteca que alojas y incrustas tú mismo — no un servicio de página de aterrizaje alojada.

¿Puedo crear un generador de páginas de aterrizaje con arrastrar y soltar?

Sí. El arrastrar y soltar está integrado en el núcleo: los bloques se arrastran de una paleta al lienzo, y los componentes pueden reordenarse y anidarse allí. Lo que defines es qué bloques existen — hero, características, precios, FAQ — ya que el núcleo no incluye ninguno por defecto.

¿Puedo exportar HTML y CSS?

Sí. editor.getHtml() devuelve el marcado que el lienzo renderizó y editor.getCss() devuelve la hoja de estilo, incluyendo las consultas de medios. También puedes llamar a getProjectData() para el JSON desde el que reabres el editor. Servir ese resultado es trabajo de tu aplicación, que es lo que mantiene las páginas publicadas rápidas.

¿Puedo crear bloques reutilizables para páginas de destino?

Sí, y es el trabajo principal de convertir GrapesJS en un creador de páginas de destino. editor.Blocks.add() registra un bloque con una etiqueta, una categoría y su contenido; una biblioteca de secciones de hero, características, testimonios, precios, bloques FAQ y CTA es lo que hace que el editor esté diseñado específicamente para ello y no genérico.

¿Puedo crear componentes personalizados?

Sí. El API de Componentes te permite definir tipos de componentes con su propio traits, hijos permitidos, acciones y comportamiento de la barra de herramientas, para que el editor pueda imponer tu sistema de diseño en lugar de permitir que los usuarios ensamblen marcado arbitrario.

¿Puedo crear un creador de páginas de destino autoalojado?

Sí. GrapesJS se ejecuta completamente dentro de tu aplicación — no hay un servicio de editor alojado en la ruta. Los datos del proyecto van a tu base de datos a través de un adaptador de almacenamiento que escribes, y las páginas publicadas se sirven desde tu propia infraestructura.

¿Puedo incrustar un creador de páginas de aterrizaje en mi SaaS?

Sí. El editor se monta en un elemento contenedor en una ruta dentro de tu propia app, así que la autenticación, la tenencia y los permisos permanecen donde ya están. El trabajo multi-inquilino — proyectos, roles, facturación, publicación — es código de aplicación, no código de editor.

¿Puedo añadir formularios?

Sí. Los componentes de formulario pueden registrarse como bloques, y el catálogo GJS.Market incluye un plugin de formularios. Las entregas deben enviarse a tu propio endpoint para que la validación, la limitación de tasas, el consentimiento y el enrutamiento CRM estén bajo tu control.

¿Puedo añadir controles SEO?

Sí, y pertenecen a tu aplicación en lugar del lienzo. Guarda título, metadescripción, canónico, Open Graph, imagen social, robots y datos estructurados como campos en el registro de página, y emítelos desde tu renderizador al publicar. Un plugin de auditoría en el editor puede revisar las páginas antes de que se publiquen.

¿Puedo añadir pruebas A/B?

Sí, pero lo implementas tú. GrapesJS no tiene función de experimento y no hay ningún plugin de pruebas A/B en el catálogo. Una vez que las páginas se almacenan como datos, una variante es otra fila contra el mismo slug: tu aplicación asigna visitantes, persiste la asignación y compara conversiones.

¿Puedo guardar proyectos en mi propia base de datos?

Sí. El módulo de almacenamiento incluye opciones locales y remotas, y Storage.add() registra un adaptador totalmente personalizado, así que cargar y almacenar se convierten en llamadas a tu propio API. Trata los datos entrantes del proyecto como entrada no confiable y valida los datos del lado del servidor.

¿Puedo crear un creador de páginas de destino de marca blanca?

Sí. El editor UI está compuesto por paneles y comandos que configuras, así que el cromo, los iconos, las fuentes y la terminología pueden ser completamente tuyos — o de tu cliente. Nada en pantalla tiene que identificar a GrapesJS.

¿Puedo usar GrapesJS con React?

Sí. Hay un envoltorio oficial de React, @grapesjs/react, que construye tu editor UI alrededor del lienzo en React. Ten en cuenta que no renderiza los componentes de React dentro del lienzo — el lienzo sigue siendo un documento DOM — y requiere que el núcleo grapesjs se instale junto a él.

¿Puedo usar GrapesJS con Next.js?

Sí, con una restricción: el editor mide el DOM en la inicialización, así que debe ser solo para el cliente. Importa el componente del editor con dynamic() y ssr: false, mantén la autenticación y la carga de datos en el lado del servidor de la ruta, y mantén el editor fuera del paquete que usan tus páginas publicadas.
Empieza

Crea tu propio constructor de páginas de destino

Empieza con el motor de edición visual GrapesJS, personalízalo para tu producto y añade las capacidades que necesitas con los plugins GJS.Market.

Desarrolladores

Empieza

Instala el núcleo, registra tu primera biblioteca de secciones y haz que una página se renderice a partir de los datos del proyecto.

Empieza
Equipos

Explorar plugins

Añade bloques, plantillas, formularios, auditoría SEO y objetivos de publicación sin escribirlos tú mismo.

Explorar plugins
Equipos de producto

Crea tu creador de páginas de destino

Dinos qué tiene que hacer el constructor y nosotros definiremos el alcance del editor, la pila de plugins y la integración.

Crea tu creador de páginas de destino

Construye el editor que tu producto necesita — en lugar de reconstruir el motor de edición desde cero.