PageKit — der selbst gehostete GrapesJS-Website-Builder, als Quellcode. Early Access sichern

Landingpage-Builder

Landingpage Builder mit GrapesJS

Bauen Sie einen visuellen Landingpage-Builder mit Drag-and-Drop-Landingpage-Elementen und wiederverwendbaren Abschnitten, responsiver Bearbeitung, benutzerdefinierten Komponenten, Formularen, SEO-Kontrollen und Ihrem eigenen Publishing-Workflow.

Visueller Drag-and-Drop-EditorIndividuelle Blöcke & KomponentenHTML- und CSS-AusgabeSelbstgehostetErweiterbar mit Plugins
your-app.com/pages/spring-launch
GrapesJS
DesktopTabletMobil

Blöcke

  • Hero
  • Features
  • Logos
  • Preisgestaltung
  • FAQ
  • CTA
  • Formular

Ebenen

  • Hero
  • Features
  • Erfahrungsberichte
  • Preisgestaltung
  • FAQ
  • CTA

Stile

  • Abstand
  • Typografie
  • Hintergrund
Eine Landingpage, bestehend aus wiederverwendbaren Abschnitten, in einem Editor, den du besitzt. Die Panels sind die, die dir GrapesJS zur Verfügung stellt; die Abschnittsbibliothek ist der Teil, den du definierst.
Probier es mal

Baue Landingpages visuell

Starte mit einer leeren Leinwand oder einer Vorlage, ziehe Abschnitte an ihren Platz, passe Stile und Inhalte an und veröffentliche über deine eigene Anwendung. Ziehe einen Block in die darunterliegende Leinwand – oder tippe auf einen Block, dann auf die Leinwand –, um die Geste zu sehen, die deine Nutzer machen werden.

Abschnitte

Ziehe einen Abschnitt hinein – oder tippe auf einen Abschnitt, dann auf die Leinwand.

Start der Frühjahrskampagne

Klicken Sie auf diesen Text und tippen Sie darüber.

Drei Gründe, warum es konvertiert

Kurz, scannbar, Nutzen zuerst.

Einfache Preisgestaltung

Drei Stufen, eine empfohlen.

Das Original

… und hier ist GrapesJS selbst

Drei öffentliche GrapesJS-Builds, die nur geladen werden, wenn du einen anfragst – es wird nichts abgerufen, bis du klickst.

In einem neuen Tab öffnen

Die Standard-GrapesJS-Demo: Blockpalette, Leinwand, Style-Manager und Ebenenbaum. Alles, was hier sichtbar ist, wird im Open-Source-Kern ausgeliefert.

grapesjs.com/demo.htmlKostenlos

Lädt eine Demo von Drittanbietern in einem iframe. Es wird nichts angefordert, bis man klickt.

Kernidee

Baue den Editor. Bau nicht die Editor-Engine.

Ein Landingpage-Builder sieht aus wie ein Feature und verhält sich wie ein Dutzend. Bevor ein Marketer einen hero-Abschnitt in Ordnung ziehen kann, muss jemand eine Leinwand, ein Komponentenmodell, ein Drag-and-Drop-System, einen Style-Manager, responsive Bearbeitung, Rückgängigmachen, Asset-Handling und ein Serialisierungsformat erstellt haben – und dann alles am Laufen halten.

Option A

Baue es von Grund auf neu

Entwirf zuerst die Editor-Architektur, dann das Produkt aus.

Du implementierst und pflegst

  • Leinwand- und Dokumentmodell
  • Drag & Drop, einschließlich Touch
  • Komponentenbaum und traits
  • Blockbibliothek und Kategorien
  • Layer-Manager
  • Style Manager und CSS-Regeln
  • Responsives Geräteschalten
  • Geschichte rückgängig machen / neu machen
  • Vermögensverwalter
  • Serialisierung und Speicherung
  • Befehls- und Plugin-Architektur

Jedes dieser Fälle ist ein Subsystem mit eigenen Randfällen, und keines davon ist das, wofür Ihre Kunden bezahlen.

Option B

Starte mit GrapesJS

Nimm die Schnitt-Engine als gegeben und passe sie an.

Bereits im Open-Source-Kern

  • Leinwand- und Komponentenmodell
  • Drag & Drop
  • Blockiert API
  • Layer-Manager
  • Style Manager
  • Gerätemanager
  • Rückgängig machen / neu machen
  • Vermögensverwalter
  • Projektserialisierung
  • Kommandos
  • Plugin-Architektur

Sie konfigurieren die Panels, registrieren Ihre eigenen Bereiche und geben stattdessen Ihr Engineering-Budget für das Produkt aus.

Sieh dir den Quickstart an
Option C

Erweiterung mit Plugins

Füge die marketingbezogenen Beiträge hinzu, ohne sie zu schreiben.

Installiert statt gebaut

  • Bibliotheken für Landingpage-Abschnitte
  • Vorlagen- und Seitenmanager
  • Formkomponenten
  • SEO und Barrierefreiheits-Audits
  • Analytics-Tags
  • Asset-Pipelines und Speicheradapter
  • Veröffentlichungs- und Exportziele

Installieren, konfigurieren, anpassen, ausliefern – und behalten Sie den Code Ihres Teams für die Teile, die sonst niemand für Sie bauen kann.

Plugins durchsuchen

GrapesJS gibt dir die Grundlage für visuelle Bearbeitung, damit dein Team sich auf das umliegende Produkt konzentrieren kann.

Umfang

Woraus ein Landing-Page-Builder eigentlich besteht

Neunzehn Subsysteme, gekennzeichnet danach, wer letztlich jedes besitzt. Der Punkt ist nicht, dass die Liste lang ist – sondern dass nur die letzten vier spezifisch für Ihr Unternehmen sind.

  • Leinwand — GrapesJS-Kern
  • Drag & Drop — GrapesJS-Kern
  • Komponenten — GrapesJS-Kern
  • Blöcke — GrapesJS-Kern
  • Ebenen — GrapesJS-Kern
  • Style Manager — GrapesJS-Kern
  • Responsive Bearbeitung — GrapesJS-Kern
  • Rückgängig machen / neu machen — GrapesJS-Kern
  • Vermögenswerte — GrapesJS-Kern
  • Serialisierung — GrapesJS-Kern
  • Kommandos — GrapesJS-Kern
  • Plugin-Architektur — GrapesJS-Kern
  • Sektionsbibliothek — Plugins
  • Vorlagen — Plugins
  • Formkomponenten — Plugins
  • SEO-Kontrollen — Deine Anwendung
  • Veröffentlichung — Deine Anwendung
  • Analytik — Deine Anwendung
  • Experimente — Deine Anwendung
Wer baut esDeine AnwendungGrapesJS-KernPlugins

GrapesJS deckt die Bearbeitungs-Engine ab. Plugins decken die landing-page-spezifischen Oberflächen ab. Alles in der letzten Spur ist der Ort, an dem sich dein Produkt tatsächlich von allen anderen unterscheidet.

Definition

Was ist ein Landingpage-Builder?

Ein Landing-Page-Builder ist ein visueller Editor, der es Nutzern ermöglicht, Kampagnenseiten zu erstellen, ohne jedes HTML-Element und jede CSS-Regel manuell schreiben zu müssen.

Es ist nicht eine einzige Funktion. Ein Landingpage-Builder ist ein editor plus Blöcke plus Vorlagen plus Formulare plus SEO plus Analysen plus Experimente plus publishing – und all das ist eine Entscheidung darüber, wem was gehört.

In der Praxis wird von einem modernen Landingpage-Builder erwartet, dass er alle Folgendes bietet:

Was die Teams von einem erwarten

  • Drag-and-Drop-Bearbeitung
  • Wiederverwendbare Abschnitte
  • Vorlagen
  • Responsive Bearbeitung
  • Individuelle Komponenten
  • Formulare
  • SEO-Kontrollen
  • Vermögensverwaltung
  • Veröffentlichung
  • Analytik
  • Experimente

Visuelles Bearbeiten, kein Code-Editing

Der Benutzer manipuliert die gerenderte Seite direkt. Ein Drag-and-Drop-Landingpage-Builder macht das Layout zu einer Geste statt einer Merge-Anfrage.

Abschnitte, keine Elemente

Marketer denken in Hero-Bereichen, Preistabellen und FAQs. Ein Landingpage-Editor, der um Abschnittsblöcke herum gebaut ist, entspricht der tatsächlichen Planung von Kampagnen.

HTML und CSS behältst du

Die Ausgabe ist Markup, die du kontrollierst und die überall rendern kann – nicht in einem proprietären Format, das an eine gehostete Laufzeit gebunden ist.

GrapesJS stellt die visuelle Bearbeitungsebene bereit. Ihre Anwendung steuert das Backend, die Daten, die Authentifizierung und den Veröffentlichungs-Workflow.

Architektur

Wie ein Landing-Page-Builder funktioniert

Es gibt eine Zeile, die in diesem Diagramm wichtig ist, und sie liegt zwischen dem Editor und deinem API. Alles darüber ist eine Autorenangelegenheit. Alles darunterliegende ist dein Produkt.

Deine Anwendung

  • Authentifizierung
  • Nutzer
  • Projekte
  • Berechtigungen
  • Datenbank
  • Abrechnung
  • Analytics
  • Veröffentlichung

Projektdaten

GrapesJS

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

Autoring auf Live-Seite

  1. Nutzer
  2. Visueller Editor
  3. GrapesJS
  4. Projektdaten
  5. Deine API
  6. Datenbank
  7. Veröffentlichen
  8. Live-Landingpage
Der Editor spricht nie direkt mit deiner Datenbank. Er gibt dir Projektdaten; deine API entscheidet, was das bedeutet, wer sie speichern darf und was beim Veröffentlichen passiert.
  • Der Editor ist ein clientseitiges Authoring-Tool. Behandle jeden Speicherstand als nicht vertrauenswürdige Eingabe, die bei deinem API ankommt.
  • Projektdaten sind die Wahrheitsquelle, von der du den Editor wieder öffnest; HTML und CSS sind die Darstellung davon.
  • Vorschau und Veröffentlichen sind zwei Routen über dieselben Daten, nicht zwei Speicherformate.

GrapesJS besitzt die Bearbeitungsfläche. Deine Anwendung besitzt Identität, Daten und Lieferung. Diese Zeile sauber zu halten, macht den Builder ersetzbar, testbar und deinen eigenen.

Fähigkeiten

Alles, was Sie für die visuelle Landingpage-Bearbeitung benötigen

Dies sind die Bearbeitungsmöglichkeiten, die GrapesJS direkt bietet, und die, die sein Plugin API erweitern soll.

Drag & Drop

Baue Layouts visuell. Komponenten werden fallen gelassen, neu geordnet und auf der Leinwand selbst verschachtelt.

Wiederverwendbare Blöcke

Registriere deine eigenen Abschnitte und Komponenten einmal; jeder Benutzer zieht dieselbe Bibliothek.

Responsive Bearbeitung

Wechsle im Editor die Geräte und schreibe Regeln pro Breakpoint. Das Standardgeräte-Set ist Desktop, Tablet, mobil im Querformat und mobiles Hochformat.

Individuelle Komponenten

Definiere Komponententypen mit eigenem traits und Verhalten, damit der Editor dem Designsystem deines Produkts entspricht.

Vermögensverwaltung

Verwalte Bilder und andere Medien über den Asset Manager, unterstützt von dem Speicher, den du bereits nutzt.

Style Manager

Steuer Typografie, Abstände, Farben und Layout über sektorgruppierte Steuerungen, die du konfigurieren kannst.

Vorlagen

Starte Kampagnen mit wiederverwendbaren Layouts statt einer leeren Leinwand, über die Vorlagen-Plugins im Katalog.

HTML & CSS

getHtml() und getCss() geben das Markup zurück, das die Leinwand gerendert hat, sodass die veröffentlichte Ausgabe dein bleibt, um zu optimieren.

Arbeitsablauf

Von der leeren Leinwand zur veröffentlichten Kampagne

  1. 1
    Schritt 1

    Wählen Sie eine Vorlage

    Öffne ein gespeichertes Layout statt einer leeren Seite. Die schnellste Kampagne startet zu 70 % fertig.

  2. 2
    Schritt 2

    Abschnitte hinzufügen

    Ziehe hero, Features, Preise, Testimonials und FAQ-Blöcke in die Reihenfolge, die die Kampagne benötigt.

  3. 3
    Schritt 3

    Inhalte anpassen

    Bearbeiten Sie die Texte auf der Leinwand, tauschen Sie die Bilder durch den Asset-Manager aus, legen Sie Links ein.

  4. 4
    Schritt 4

    Responsive Styles anpassen

    Wechsle das Gerät und korrigiere das Layout pro Breakpoint, bevor es jemand auf einem Handy sieht.

  5. 5
    Schritt 5

    Formulare hinzufügen

    Gib das Capture-Formular ein und richte es auf dein eigenes Endpunkt.

  6. 6
    Schritt 6

    Vorschau

    Rendere die Seite aus Projektdaten auf einer Vorschauroute – demselben Renderer, der auch die Live-Seite bedient.

  7. 7
    Schritt 7

    Veröffentlichen

    Schreiben Sie den HTML-, CSS- und SEO-Datensatz, weisen Sie den Slug zu und servieren Sie ihn von Ihrer eigenen Infrastruktur aus.

Einmal erstellen. Kampagnenübergreifend wiederverwenden.

Blockbibliothek

Erstellen Sie eine wiederverwendbare Landingpage-Blockbibliothek

Der GrapesJS-Kern liefert null Blöcke aus. Das ist kein Auslass – es ist der Erweiterungspunkt. Die Blockbibliothek, die du registriert, ist genau das, was einen generischen visuellen Editor in einen speziell entwickelten Landingpage-Builder verwandelt, und sie ist der Code, den du am stärksten benutzen wirst.

  • Hero

    Schlagzeile, Unterüberschrift und der primäre Aufruf zum Handeln.

  • Features

    Zwei bis vier Vorteilsspalten mit Symbolen.

  • Logo-Wolke

    Kunden- oder Integrationslogos als sozialer Beweis.

  • Erfahrungsberichte

    Zitate, Namen und Avatare in der Nähe des Umwandlungspunkts.

  • Preisgestaltung

    Gestufte Pläne mit einer empfohlenen Spalte.

  • Vergleich

    Feature-Tabelle gegen die Alternative, die der Besucher abwägt.

  • FAQ

    Einspruchsbearbeitung, in den eigenen Worten des Besuchers.

  • Kontaktformular

    Die Lead-Capture-Fläche, postet an deinen API.

  • Newsletter

    Single-Field-Abonnieren, für den Besucher, der noch nicht bereit ist.

  • Call to Action

    Die wiederholte Frage, ganz unten auf der Seite.

  • Fuß

    Navigations-, Rechts- und Vertrauenssignale.

Quickstart

Die ersten zwanzig Linien

Installiere den Kern, montiere ihn und registriere die Abschnitte, die ihn zu einem Landingpage-Builder machen. Alles andere auf dieser Seite ist eine Entscheidung, die auf diesen Zeilen liegt.

Installation

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 });
});

Jeder Block ist ein Label, eine Kategorie und ein Block Markup. Gib dem Markup einen Komponententyp, und es erhält außerdem traits, Constraints und eine eigene Werkzeugleiste.

Vorlagen

Beginnen Sie mit Landingpage-Vorlagen

Eine Vorlage ist ein gespeichertes Projekt, das ein Nutzer anstelle einer leeren Leinwand öffnet. Die folgenden Kategorien sind die Layout-Arten, die Marketingteams verlangen – die darunterliegenden Plugins ermöglichen es Ihren Nutzern, sie zu speichern, zu verwalten und wieder zu öffnen.

Layoutarten, die Teams verlangen

  • SaaS
  • Start-up
  • Produkt
  • Agentur
  • Veranstaltung
  • App
  • Newsletter
  • Webinar

Das sind Layout-Arten, keine Kataloglisten: Es gibt keinen Template-Produkttyp auf GJS.Market. Die unten stehenden Template- und Seitenmanager sind echte Plugins, die deinem Builder einen Platz zum Aufbewahren geben.

Lead-Erfassung

Verwandeln Sie Landingpages in Lead-Generierungsseiten

Eine Landingpage ohne Aufnahmefläche ist eine Broschüre. Die Formularkomponente ist eine Redaktionsaufgabe; alles nach dem Absenden-Button gehört Ihnen.

Übermittlungspfad

  1. Landingpage
  2. Formular
  3. Übermittlung
  4. Deine API
  5. CRM / Datenbank
Behalte dein Backend und CRM unter deiner Kontrolle. Eine veröffentlichte Seite, die direkt an einen Drittanbieter gepostet wird, gibt ihnen deine Funnel-Daten zusammen mit dem Lead.

Routen Sie jede Einreichung über Ihren eigenen Endpunkt. Dort gehören Validierung, Rate-Limiting, Spam-Behandlung, Zustimmung und CRM-Routing – und keine davon sollte ein Seitenredakteur entscheiden.

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 });
});

Kontaktformulare

Name, Arbeits-E-Mail, Nachricht. Der Standard-Vertriebspfad auf einer B2B-Kampagnenseite.

Newsletter-Formulare

Einzelfeld, wenig Reibung, für Besucher, die interessiert, aber noch nicht bereit sind.

Anmeldeformulare

Direkt ins Produkt, mit den Kampagnenparametern.

Führungsqualifikationsformen

Unternehmensgröße, Rolle, Budget – die Vertriebsbedürfnisse des Feldes vor dem ersten Anruf.

Suche

Gib jeder Landingpage eigene SEO-Kontrollen

Eine Kampagnenseite, die ein Marketer ohne Entwickler nicht benennen, beschreiben oder kanonisieren kann, ist nicht fertig. GrapesJS bearbeitet den Hauptteil des Dokuments; der Kopf gehört zu Ihrer Anwendung – daher muss der SEO-Datensatz von Anfang an Teil Ihres Seitenmodells sein.

Seiten-SEO

Titel
<title>
Spring Launch — Acme
Meta-Beschreibung
meta[name=description]
Ship campaign pages without a developer…
Kanonische URL
link[rel=canonical]
https://acme.com/spring
Open Graph
meta[property^=og:]
og:title, og:description, og:type
Soziales Image
og:image
/og/spring-launch.png
Robots
meta[name=robots]
index, follow
Strukturierte Daten
application/ld+json
{ "@type": "WebPage" }

Gespeichert neben den Projektdaten, auf demselben Bildschirm bearbeitet, die von deinem Renderer beim Veröffentlichen angezeigt werden.

Behandeln Sie SEO-Metadaten als erstklassiges Feld im Seiteneintrag, nicht als etwas, das nach dem Start hinzugefügt wird. Marketer sollten einen Titel ändern können, ohne eine Pull Request zu eröffnen.

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');
}
Experimente

Bauen → veröffentlichen → messen → verbessern

Ein Landing-Page-Builder wird viel wertvoller, wenn Teams an Kampagnen iterieren können, anstatt Seiten als statische Assets zu behandeln. Sobald eine Seite Daten statt einer Datei ist, ist eine Variante günstig: Es ist eine weitere Projektzeile, die auf denselben Slug zeigt.

  1. Editor

    Bau

    Dupliziere die Seite im Editor und ändere eine Sache – die Überschrift, das Angebot, die Formularlänge.

  2. Deine App

    Veröffentlichen

    Beide Varianten veröffentlichen auf denselben Slug, mit den Gewichten, die deine Anwendung bestimmt.

  3. Deine App

    Maß

    Weise einen Besucher einmal zu, bewahre die Zuweisung auf und melde sie zusammen mit deinen Umwandlungsereignissen.

  4. Deine App

    Verbessern

    Befördere den Gewinner auf die Standardposition und starte den nächsten Test von diesem aus.

  1. Traffic
    • Variante A
    • Variante B
  2. Conversions
  3. Gewinner

Zuweisung, Gewichtung und Bedeutung sind Anwendungslogik. GrapesJS ist über den Punkt hinaus, an dem die beiden Varianten verfasst wurden, nicht mehr beteiligt – genau deshalb kann es außerhalb des Serving-Pfades bleiben.

Im GJS.Market-Katalog gibt es kein A/B-Test-Plugin, und GrapesJS hat keine Experimentierfunktion. Dies ist ein Muster, das in Ihrer Anwendung implementiert werden sollte, kein Produkt zum Installieren – und ein Page Builder macht es preiswert.

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);
Messung

Verbinden Sie Ihre Landingpages mit Ihrem Analyse-Stack

Du musst keine Analyseplattform in deinem Page Builder aufbauen. Du brauchst veröffentlichte Seiten, um die Ereignisse auszusenden, die dein bestehender Stack bereits versteht.

Analytische Events

Feuer auf die Interaktionen, die wichtig sind – Form von Einsendungen, CTA-Klicks, Scrolltiefe auf langen Seiten.

Konversionsverfolgung

Verknüpfe einen Beitrag mit der Seite, der Variante und der Kampagne, die sie hervorgebracht hat.

Seitenaufrufe

Die Basislinie jeder zweiten Zahl ist ein Verhältnis von .

Kampagnenparameter

Bewahren Sie UTM-Werte vom ersten Klick bis zum CRM-Datensatz.

Externe Integrationen

Verschick den Container oder markiere den Container, den dein Team bereits nutzt, anstatt eine Berichtsschicht zu erfinden.

Nutzen Sie Ihre eigene Analyse-Infrastruktur. Die Aufgabe des Entwicklers ist es, sicherzustellen, dass jede veröffentlichte Seite die richtigen Tags und Parameter trägt, ohne dass ein Marketer sie sich merken muss.

Ausgabe

Deine Landingpages. Dein Stack.

Der Editor erzeugt zwei Dinge: Projektdaten, von denen du sie wieder öffnest, und HTML plus CSS, die du bedienst. Beide sind deine, in Formaten, die du lesen kannst.

  1. GrapesJSOpen Source
  2. ProjektdatenAusgabe
  3. HTML + CSSAusgabe
  4. Dein BackendDeins
  5. Dein Hosting / CDNDeins
Open Source

GrapesJS

Die Bearbeitungs-Engine. Selbstgehostet, BSD-3-Clause-Lizenz, kein gehosteter Dienst im Pfad.

Ausgabe

Projektdaten

Das JSON, als das deine Seiten gespeichert sind. Lesbar, unterschiedlich und dein zum Übertragen.

Ausgabe

HTML + CSS

Was getHtml() und getCss() zurückgeben – das genaue Markup, das die Leinwand gerendert hat.

Deins

Dein Backend

Auth, Versionierung, Berechtigungen und der Veröffentlichungsendepunkt. Der Teil, der tatsächlich dein Produkt ist.

Deins

Dein Hosting / CDN

Von wo aus veröffentlichte Seiten bereitgestellt werden, je nach eigener Leistung und Caching.

Behalte die Kontrolle über deine Projektdaten, HTML/CSS und die Veröffentlichungsinfrastruktur. Selbsthosting garantiert nicht, dass die Migration kostenlos ist – du besitzt weiterhin die Integration, die du geschrieben hast –, aber es bedeutet, dass nichts, was du baust, hinter dem Export-Button von jemand anderem sitzt.

Bauen vs. übernehmen

Einen Landing-Page-Builder von Grund auf bauen oder GrapesJS verwenden?

Die gleichen vierzehn Funktionen, zweimal gelesen. Links ist jede Reihe ein Projekt. Rechts sind die meisten Konfigurationen – und die drei, die es nicht sind, sind ehrlich beschriftet.

LeistungsfähigkeitVon Grund aufGrapesJS
LeinwandSelbst bauenEnthalten
Drag & DropSelbst bauenEnthalten
KomponentenSelbst bauenEnthalten
BlöckeSelbst bauenErweiterbar
DesignSelbst bauenEnthalten
Responsive BearbeitungSelbst bauenEnthalten
VermögenswerteSelbst bauenErweiterbar
LagerungSelbst bauenErweiterbar
VorlagenSelbst bauenErweiterbar
Plugin-ArchitekturSelbst bauenEnthalten
FormulareSelbst bauenErweiterbar
SEO-KontrollenSelbst bauenIn deinen Stack integrieren
A/B-TestsSelbst bauenIn deinen Stack integrieren
VeröffentlichungSelbst bauenIn deinen Stack integrieren

Vergleicht mit der GrapesJS-Dokumentation und dem GJS.Market-Katalog auf 2026-09-03. "Erweiterbar" bedeutet, dass es ein API und bestehende Plugins dafür gibt; "Integrieren" bedeutet, dass der Editor es absichtlich nicht tut und deine Anwendung es tun sollte.

Nutze GrapesJS für die Editor-Engine. Nutze deine eigene Anwendung für alles, was spezifisch für dein Unternehmen ist.

Plugins

Bauen Sie Ihren Landing-Page-Builder-Stack auf

Reale Einträge aus dem GJS.Market-Katalog, gruppiert nach den vier Fähigkeitsbereichen, aus denen ein Landingpage-Builder zusammengestellt wird. Preise und Verfügbarkeit werden beim Bau aus dem Katalog vorgelesen.

Kuratiert

Wähle die Plugins aus, die dein Build tatsächlich benötigt

Drei Einkaufslisten, eingerahmt nach dem, was du baust, statt nach Katalogkategorie.

Die Preise werden beim Bau aus dem Katalog abgelesen und können sich geändert haben – die Produktseite ist maßgeblich.

Zwei Wege

Fang mit dem Kern an. Füge hinzu, was du brauchst.

GrapesJS bietet die Grundlage für das visuelle Bearbeiten. GJS.Market-Plugins ermöglichen es, spezialisierte Funktionen hinzuzufügen, ohne jede Funktion selbst bauen zu müssen.

Weg A

Bau alles selbst

Jede Fähigkeit wird zu einem Ticket, einer Überprüfung und einer Wartungsvereinbarung.

  1. Mehr Ingenieurwesen
  2. Mehr Wartung
  3. Mehr interner Code zu besitzen
  4. Ein längerer Weg zur ersten veröffentlichten Seite
Weg B

Erweiterung mit Plugins

Vier Schritte, pro Fähigkeit wiederholt, auf einer nicht geschriebenen Engine.

  1. Installation
  2. Konfigurieren
  3. Anpassen
  4. Schiff
Anwendungsfall

Baue einen SaaS-Landingpage-Builder

Einen Page Builder in ein Produkt einzubauen, ist größtenteils kein Problem des Editors. Der Editor ist ein Weg; der Rest ist die Multi-Tenant-Maschinerie drumherum.

Wo der Editor sitzt

  1. Deine App
  2. Authentifizierung
  3. Organisationen
  4. Projekte
  5. GrapesJS-Editor
  6. Projektspeicher
  7. Veröffentlichung

Nutzer und Teams

Wer den Editor öffnen kann und wessen Seiten er sieht, wenn er es tut.

Projekte

Die Einheit, zu der ein Page gehört. Meistens dieselbe Einheit, zu der du abrechnest.

Berechtigungen

Bearbeiten, veröffentlichen und löschen sind drei verschiedene Rechte. Veröffentlichen ist das, was es wert ist, geschützt zu werden.

Abrechnung

Seitenanzahl, Sitzplatzanzahl oder Veröffentlichungsvolumen – all das weiß der Editor gerne nicht.

White-Label

Dein Chrome, deine Schriftarten, deine Symbole. Der Editor UI ist eine Konfiguration, keine feste Benutzeroberfläche.

Veröffentlichung

Slugs, benutzerdefinierte Domains, Versionen und Rollbacks, bereitgestellt von Ihrer Infrastruktur.

Der Editor ist ein einziger Bildschirm in deinem Produkt. Mietverhältnisse, Berechtigungen und Abrechnung machen es zu einer Funktion, die du verkaufen kannst.

Anwendungsfall

Erstellen Sie einen White-Label-Landingpage-Builder für Agenturen

Das Problem einer Agentur ist nicht, einen einseitigen Builder zu bauen. Sie baut nicht dasselbe für den elften Kunden wieder auf.

Agenturbranding

Oder das des Kunden. Der Editor Chrome, die Icons und die Typografie können pro Tenant eingestellt werden.

Wiederverwendbare Blöcke

Eine Sektionsbibliothek, einmal gepflegt, auf jedes Konto ausgeliefert.

Kundenprojekte

Isolierte Projekte unter einer Installation, mit Assets und Vorlagen pro Kunde.

Vorlagen

Starte einen neuen Kunden mit den Layouts, die beim letzten funktioniert haben.

Berechtigungen

Lass einen Kunden die Texte bearbeiten, ohne dass er die Seite umstrukturiert oder ungeprüft veröffentlicht.

Veröffentlichung

Deployen Sie auf die Domain und das Hosting des Kunden, ohne dass die Agentur zum Hosting-Unternehmen wird.

Erstellen Sie ein einziges Bearbeitungssystem und verwenden Sie es in mehreren Kundenprojekten wieder. Die Blöcke und Vorlagen werden zum Vermögenswert der Agentur; der Kunde sieht immer nur seine eigene Marke.

Lizenzierung

Warum einen Open-Source-Landingpage-Builder verwenden?

Der GrapesJS-Kern wird unter der BSD-3-Clause-Lizenz und dem offiziellen React-Wrapper unter MIT veröffentlicht. Beide erlauben die kommerzielle Nutzung. Die praktischen Konsequenzen:

Selbsthosting

Der Editor läuft in deiner Anwendung. Zwischen dir und deinen Nutzern gibt es keinen gehosteten Editor-Service.

Anpassung

Panels, Befehle und Komponententypen sind alle austauschbar, nicht nur thematisch.

Kontrolle über Daten

Projektdaten befinden sich in Ihrer Datenbank, in einem Format, das Sie lesen und übertragen können.

Eigene UI

Baue die Editor-Oberfläche, die deine Nutzer brauchen, statt die, die ein Anbieter ausliefert.

Benutzerdefinierte Integrationen

Ihr CRM, Ihre Asset-Speicherung, Ihr Deploy-Ziel – verdrahtet über das Plugin API.

Erweiterbarkeit

Eine dokumentierte Plugin-Architektur und ein bestehender Katalog, auf den man zurückgreifen kann.

Keine Abhängigkeit vom proprietären Editor

Nichts, was du baust, hängt davon ab, dass ein gehosteter Editor weiterhin zu seinen aktuellen Bedingungen existiert.

Leistung

Leistungsüberlegungen

Ein Page Builder hat zwei sehr unterschiedliche Leistungsbudgets, und deren Verwechslung ist der häufigste Fehler in dieser Architektur.

  • Lazy-Load den Editor

    Importiere es dynamisch, damit es nie in einem gemeinsamen Bundle landet.

  • Initialisieren Sie nur dort, wo es nötig ist

    Eine Editor-Instanz auf dem Autorenweg montierte clientseitige Version.

  • Vermeiden Sie unnötige Neuinterpretationen

    Der Editor besitzt sein eigenes DOM. Das Neurendern des Wrappers bei jedem Tastendruck bekämpft das.

  • Große Asset-Bibliotheken optimieren

    Paginieren und den Asset Manager lazy laden, anstatt jeden Upload aufzulisten.

  • Lazy-load-lastlastige Plugins

    Lade ein Plugin, wenn das benötigte Panel geöffnet wird, nicht im Editor-Init.

  • Separater Editor und öffentliche Laufzeiten

    Zwei Einstiegspunkte, zwei Budgets. Die veröffentlichte Seite sollte den Editor überhaupt nicht importieren.

  • Unabhängige Optimierung der veröffentlichten Seiten

    Bilder, Schriftarten und kritische CSS im Output, abgestimmt wie jede andere Produktionsseite.

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');
}

Der Editor ist eine Autorenumgebung. Veröffentlichte Landingpages benötigen nicht unbedingt die volle Editor-Laufzeit – und eine Kampagnenseite, die jedem Besucher ein Editor-Bundle zustellt, hat den Grund für die Erstellung eines Editors über Bord geworfen.

Sicherheit

Sicherheitsaspekte

Ein Visual Builder akzeptiert strukturierte Eingaben eines Browsers und wandelt sie in das von dir bereitgestellte Markup um. Jeder folgende Punkt folgt aus diesem einen Satz.

  • Authentifiziere den APIs

    Endpunkte für Laden, Speichern und Veröffentlichen sind privilegiert. Behandeln Sie sie so.

  • Berechtigungen pro Aktion validieren

    Eine Seite bearbeiten zu dürfen ist nicht dasselbe wie sie veröffentlichen zu dürfen.

  • Validiere hochgeladene Assets

    Überprüfe Typ, Größe und Inhalte auf Serverseite und serviere Nutzeruploads von einem Ursprungspunkt, den du isolieren möchtest.

  • Nutzergenerierte Inhalte bereinigen

    Wo Seitenautoren nicht vollständig vertraut werden, desinfizieren Sie sowohl beim Hinausgehen als auch beim Einsteigen.

  • Projektdaten validieren

    Project JSON, das bei deinem API ankommt, ist eine vertrauenswürdige Eingabe. Parse es, speichere es nicht einfach.

  • Schützen Sie den Veröffentlichungs-Endpunkt

    Das Veröffentlichen verändert, was die Öffentlichkeit sieht. Begrenze die Rate, logge es und mache es rückgängig.

  • Vertraue niemals dem clientseitigen Zustand

    Alles, was der Editor sendet, kann gefälscht werden. Übernehmen Sie Eigentumsrechte und Limits auf dem Server wieder.

Dies ist eine Anfangscheckliste, keine Garantie. Gestalten Sie Ihre eigene Bereitstellung als Bedrohungsmodell – besonders wenn die Personen, die Seiten bearbeiten, nicht die Eigentümer der Domain sind.

Umfang

Fang klein an. Skaliere zu einer vollständigen Landingpage-Plattform.

Drei Stufen, jeweils aussendbar. Der Fehler ist, zu versuchen, die dritte zu erreichen, bevor jemand eine Seite vom ersten veröffentlicht hat.

  1. 1Etappe 1

    MVP

    Eine Person kann eine Seite erstellen und veröffentlichen.

    • Visueller Editor
    • Grundblöcke
    • Vorlagen
    • Einfache Speicherung
    • Veröffentlichung
    Sieh dir den Quickstart an
  2. 2Etappe 2

    Produktion

    Ein Team kann sich darauf verlassen, auch wenn du nicht im Raum bist.

    • Authentifizierung
    • Projekte
    • Vermögensverwaltung
    • Individuelle Komponenten
    • Berechtigungen
    • Versionierung
    • SEO
    • Formulare
    Plugins durchsuchen
  3. 3Etappe 3

    Marketingplattform

    Der Bauunternehmer wird zu etwas, das du verkaufen kannst.

    • A/B-Tests
    • Analytik
    • Vorlagenbibliothek
    • Kampagnenmanagement
    • Teams
    • White-Label
    • Abrechnung
    SaaS-Seitenbauer

Jede Stufe nach der ersten ist eine Produktentscheidung, keine Entscheidung über den Editor – genau deshalb sollte der Editor nicht das sein, was du noch baust.

FAQ

Häufige Fragen

Was ist ein Landingpage-Builder?

Ein Landing-Page-Builder ist ein visueller Editor zum Erstellen von Kampagnenseiten, ohne HTML und CSS von Hand zu schreiben. In der Praxis kombiniert er eine Drag-and-Drop-Leinwand, eine wiederverwendbare Abschnittsbibliothek, Vorlagen, responsive Bearbeitung, Formulare, SEO-Kontrollen und einen Veröffentlichungsschritt.

Kann ich mit GrapesJS einen Landingpage-Builder bauen?

Ja. GrapesJS ist ein Framework zum Erstellen visueller Editoren statt eines fertigen Produkts, daher stellt es die Leinwand, das Komponentenmodell, Drag & Drop, den Style-Manager, den Layer Tree, den Asset-Manager und die Plugin-Architektur bereit, und du baust die landing-page-spezifischen Teile obendrauf: deine Abschnittsbibliothek, Vorlagen und die darum herum umliegende Anwendung.

Ist GrapesJS ein Open-Source-Landingpage-Builder?

GrapesJS ist Open Source: Der Core wird unter der BSD-3-Clause-Lizenz veröffentlicht und der offizielle React-Wrapper unter MIT. Beide erlauben kommerzielle Nutzung. Es handelt sich um eine Bibliothek, die Sie selbst hosten und einbetten – kein gehosteter Landingpage-Service.

Kann ich einen Drag-and-Drop-Landingpage-Builder erstellen?

Ja. Drag & Drop ist im Kern eingebaut: Blöcke werden von einer Palette auf die Leinwand gezogen, und Komponenten können dort neu geordnet und verschachtelt werden. Was du definierst, ist, welche Blöcke existieren – hero, Features, Preisgestaltung, FAQ – da der Kern standardmäßig keine ausliefert.

Kann ich HTML und CSS exportieren?

Ja. editor.getHtml() gibt das Markup zurück, das die Leinwand gerendert hat, und editor.getCss() liefert das Stylesheet, einschließlich Medienabfragen. Du kannst auch getProjectData() für das JSON aufrufen, von dem du den Editor wieder öffnest. Die Bereitstellung dieses Outputs ist Aufgabe deiner Anwendung, und das sorgt dafür, dass die veröffentlichten Seiten schnell sind.

Kann ich wiederverwendbare Landingpage-Blöcke erstellen?

Ja, und es ist die Hauptaufgabe, GrapesJS in einen Landingpage-Builder zu verwandeln. editor.Blocks.add() registriert einen Block mit einem Label, einer Kategorie und dessen Inhalt; eine Sektionsbibliothek mit hero, Features, Testimonials, Preisen, FAQ- und CTA-Blöcken ist das, was den Editor speziell entwickelt und nicht generisch ist.

Kann ich benutzerdefinierte Komponenten erstellen?

Ja. Das Components API erlaubt es dir, Komponententypen mit eigenem traits, erlaubten Kindern, Werkzeugleistenaktionen und Verhalten zu definieren, sodass der Editor dein Designsystem durchsetzen kann, anstatt Benutzer willkürlich zusammenstellen zu lassen.

Kann ich einen selbstgehosteten Landingpage-Builder erstellen?

Ja. GrapesJS läuft vollständig innerhalb Ihrer Anwendung – es gibt keinen gehosteten Editor-Dienst im Pfad. Projektdaten gelangen über einen von Ihnen geschriebenen Speicheradapter in Ihre Datenbank, und veröffentlichte Seiten werden von Ihrer eigenen Infrastruktur bereitgestellt.

Kann ich einen Landingpage-Builder in meinen SaaS einbetten?

Ja. Der Editor mountet in ein Container-Element auf einer Route in Ihrer eigenen App, sodass Authentifizierung, Mieter und Berechtigungen dort bleiben, wo sie bereits sind. Die Multi-Tenant-Arbeit – Projekte, Rollen, Abrechnung, Veröffentlichung – ist Anwendungscode, kein Editor-Code.

Kann ich Formulare hinzufügen?

Ja. Formularkomponenten können als Blöcke registriert werden, und der GJS.Market-Katalog enthält ein Formular-Plugin. Einreichungen sollten an deinem eigenen Endpunkt posten, damit Validierung, Ratenbegrenzung, Zustimmung und CRM-Routing unter deiner Kontrolle bleiben.

Kann ich SEO-Kontrollen hinzufügen?

Ja, und sie gehören zu deiner Anwendung und nicht zur Leinwand. Speichere Titel, Metabeschreibung, kanonische, Open Graph, soziale Bilder, Robots und strukturierte Daten als Felder im Seiteneintrag und ermittle sie beim Veröffentlichen aus deinem Renderer. Ein In-Editor-Auditing-Plugin kann Seiten überprüfen, bevor sie live gehen.

Kann ich A/B-Tests hinzufügen?

Ja, aber du implementierst es. GrapesJS hat keine Experimentfunktion und es gibt kein A/B-Test-Plugin im Katalog. Sobald Seiten als Daten gespeichert sind, ist eine Variante eine weitere Zeile gegen denselben Slug – deine Anwendung weist Besucher zu, speichert die Zuweisung und vergleicht Konvertierungen.

Kann ich Projekte in meiner eigenen Datenbank speichern?

Ja. Das Speichermodul enthält lokale und entfernte Optionen, und Storage.add() registriert einen vollständig angepassten Adapter, sodass Laden und Speicher zu Aufrufen zu deinem eigenen API werden. Behandle eingehende Projektdaten als nicht vertrauenswürdige Eingabe und validiere sie serverseitig.

Kann ich einen White-Label-Landingpage-Builder erstellen?

Ja. Der Editor UI besteht aus Panels und Kommandos, die du konfigurierst, sodass Chrome, Icons, Schriftarten und Terminologie ganz von dir selbst – oder deinem Kunden – sein können. Nichts auf dem Bildschirm muss GrapesJS identifizieren.

Kann ich GrapesJS mit React verwenden?

Ja. Es gibt einen offiziellen React-Wrapper, @grapesjs/react, der deinen Editor UI um die Leinwand in React aufbaut. Beachte, dass er keine React-Komponenten innerhalb der Leinwand rendert – die Leinwand bleibt ein DOM-Dokument – und dass der grapesjs-Kern parallel installiert werden muss.

Kann ich GrapesJS mit Next.js verwenden?

Ja, mit einer Einschränkung: Der Editor misst den DOM bei der Initialisierung, daher muss es nur clientsspezifisch sein. Importiere die Editor-Komponente mit dynamic() und ssr: false, halte die Authentifizierung und das Datenladen auf der Serverseite der Route und halte den Editor aus dem Bundle deiner veröffentlichten Seiten heraus.
Leg los.

Baue deinen eigenen Landingpage-Builder

Beginne mit der GrapesJS-Visual-Editing-Engine, passe sie für dein Produkt an und füge die benötigten Funktionen mit GJS.Market-Plugins hinzu.

Entwickler

Leg los

Installiere den Core, registriere deine erste Abschnittsbibliothek und lass eine Seite aus Projektdaten rendern.

Leg los
Teams

Durchsuchen von Plugins

Füge Blöcke, Vorlagen, Formulare, SEO-Auditing- und Veröffentlichungsziele hinzu, ohne sie selbst zu schreiben.

Durchsuchen von Plugins
Produktteams

Baue deinen Landingpage Builder

Sagen Sie uns, was der Builder tun muss, und wir werden den Editor, den Plugin-Stack und die Integration scopen.

Baue deinen Landingpage Builder

Baue den Editor, den dein Produkt benötigt – anstatt die Editor-Engine von Grund auf neu zu bauen.