Start der Frühjahrskampagne
Klicken Sie auf diesen Text und tippen Sie darüber.
PageKit — der selbst gehostete GrapesJS-Website-Builder, als Quellcode. Early Access sichern
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.
Blöcke
Ebenen
Stile
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.
Klicken Sie auf diesen Text und tippen Sie darüber.
Kurz, scannbar, Nutzen zuerst.
Drei Stufen, eine empfohlen.
Stile
Akzent
Drei öffentliche GrapesJS-Builds, die nur geladen werden, wenn du einen anfragst – es wird nichts abgerufen, bis du klickst.
In einem neuen Tab öffnenDie Standard-GrapesJS-Demo: Blockpalette, Leinwand, Style-Manager und Ebenenbaum. Alles, was hier sichtbar ist, wird im Open-Source-Kern ausgeliefert.
Lädt eine Demo von Drittanbietern in einem iframe. Es wird nichts angefordert, bis man klickt.
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.
Entwirf zuerst die Editor-Architektur, dann das Produkt aus.
Du implementierst und pflegst
Jedes dieser Fälle ist ein Subsystem mit eigenen Randfällen, und keines davon ist das, wofür Ihre Kunden bezahlen.
Nimm die Schnitt-Engine als gegeben und passe sie an.
Bereits im Open-Source-Kern
Sie konfigurieren die Panels, registrieren Ihre eigenen Bereiche und geben stattdessen Ihr Engineering-Budget für das Produkt aus.
Sieh dir den Quickstart anFüge die marketingbezogenen Beiträge hinzu, ohne sie zu schreiben.
Installiert statt gebaut
Installieren, konfigurieren, anpassen, ausliefern – und behalten Sie den Code Ihres Teams für die Teile, die sonst niemand für Sie bauen kann.
Plugins durchsuchenGrapesJS gibt dir die Grundlage für visuelle Bearbeitung, damit dein Team sich auf das umliegende Produkt konzentrieren kann.
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.
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.
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
Der Benutzer manipuliert die gerenderte Seite direkt. Ein Drag-and-Drop-Landingpage-Builder macht das Layout zu einer Geste statt einer Merge-Anfrage.
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.
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.
Die gleiche visuelle Bearbeitungs-Engine unterstützt sehr unterschiedliche Produkte. Was sich ändert, ist die Anwendung darum herum – wer sich einloggt, was sie tun dürfen und wo die Seite landet.
Starten Sie Produkt- und Kampagnenseiten schnell, ohne ein technisches Ticket pro Schlagzeilenänderung.
Drag-and-Drop-MechanikLassen Sie Kunden direkt in Ihrem SaaS Seiten erstellen, unter ihrem eigenen Konto und mit ihrem eigenen Branding.
Bau eines SaaS-BuildersErstellen Sie ein wiederverwendbares Bearbeitungssystem und wenden Sie es auf mehrere Kundenprojekte an.
White-Label-BuilderBieten Sie ein vollständig gebrandetes Seitenerstellungserlebnis, bei dem auf dem Bildschirm nichts GrapesJS anzeigt.
White-Label-AnsatzGeben Sie den Content-Teams visuelle Bearbeitung zusätzlich zum bereits vorhandenen Content-Modell.
Kopflose CMS-BearbeitungErlauben Sie dem Marketingteam, Seiten ohne technische Unterstützung in Ihren eigenen Tools zu erstellen.
Open-Source-AnsatzShipe und iteriere Kampagnenseiten, ohne vorher ein komplettes CMS zu erstellen.
Die HTML-AusgabeIntegrieren Sie die visuelle Seitenerstellung direkt in eine andere Anwendung, die Ihre Kunden bereits nutzen.
Einbettung eines BuildersDeine Anwendung
Projektdaten
GrapesJS
Autoring auf Live-Seite
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.
Dies sind die Bearbeitungsmöglichkeiten, die GrapesJS direkt bietet, und die, die sein Plugin API erweitern soll.
Baue Layouts visuell. Komponenten werden fallen gelassen, neu geordnet und auf der Leinwand selbst verschachtelt.
Registriere deine eigenen Abschnitte und Komponenten einmal; jeder Benutzer zieht dieselbe Bibliothek.
Wechsle im Editor die Geräte und schreibe Regeln pro Breakpoint. Das Standardgeräte-Set ist Desktop, Tablet, mobil im Querformat und mobiles Hochformat.
Definiere Komponententypen mit eigenem traits und Verhalten, damit der Editor dem Designsystem deines Produkts entspricht.
Verwalte Bilder und andere Medien über den Asset Manager, unterstützt von dem Speicher, den du bereits nutzt.
Steuer Typografie, Abstände, Farben und Layout über sektorgruppierte Steuerungen, die du konfigurieren kannst.
Starte Kampagnen mit wiederverwendbaren Layouts statt einer leeren Leinwand, über die Vorlagen-Plugins im Katalog.
getHtml() und getCss() geben das Markup zurück, das die Leinwand gerendert hat, sodass die veröffentlichte Ausgabe dein bleibt, um zu optimieren.
Wählen Sie eine Vorlage
Öffne ein gespeichertes Layout statt einer leeren Seite. Die schnellste Kampagne startet zu 70 % fertig.
Abschnitte hinzufügen
Ziehe hero, Features, Preise, Testimonials und FAQ-Blöcke in die Reihenfolge, die die Kampagne benötigt.
Inhalte anpassen
Bearbeiten Sie die Texte auf der Leinwand, tauschen Sie die Bilder durch den Asset-Manager aus, legen Sie Links ein.
Responsive Styles anpassen
Wechsle das Gerät und korrigiere das Layout pro Breakpoint, bevor es jemand auf einem Handy sieht.
Formulare hinzufügen
Gib das Capture-Formular ein und richte es auf dein eigenes Endpunkt.
Vorschau
Rendere die Seite aus Projektdaten auf einer Vorschauroute – demselben Renderer, der auch die Live-Seite bedient.
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.
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.
Schlagzeile, Unterüberschrift und der primäre Aufruf zum Handeln.
Zwei bis vier Vorteilsspalten mit Symbolen.
Kunden- oder Integrationslogos als sozialer Beweis.
Zitate, Namen und Avatare in der Nähe des Umwandlungspunkts.
Gestufte Pläne mit einer empfohlenen Spalte.
Feature-Tabelle gegen die Alternative, die der Besucher abwägt.
Einspruchsbearbeitung, in den eigenen Worten des Besuchers.
Die Lead-Capture-Fläche, postet an deinen API.
Single-Field-Abonnieren, für den Besucher, der noch nicht bereit ist.
Die wiederholte Frage, ganz unten auf der Seite.
Navigations-, Rechts- und Vertrauenssignale.
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 grapesjsimport 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.
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
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.
Eine Landingpage ohne Aufnahmefläche ist eine Broschüre. Die Formularkomponente ist eine Redaktionsaufgabe; alles nach dem Absenden-Button gehört Ihnen.
Übermittlungspfad
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.
// 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 });
});Name, Arbeits-E-Mail, Nachricht. Der Standard-Vertriebspfad auf einer B2B-Kampagnenseite.
Einzelfeld, wenig Reibung, für Besucher, die interessiert, aber noch nicht bereit sind.
Direkt ins Produkt, mit den Kampagnenparametern.
Unternehmensgröße, Rolle, Budget – die Vertriebsbedürfnisse des Feldes vor dem ersten Anruf.
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
<title>meta[name=description]link[rel=canonical]meta[property^=og:]og:imagemeta[name=robots]application/ld+jsonGespeichert 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.
// 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');
}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.
Bau
Dupliziere die Seite im Editor und ändere eine Sache – die Überschrift, das Angebot, die Formularlänge.
Veröffentlichen
Beide Varianten veröffentlichen auf denselben Slug, mit den Gewichten, die deine Anwendung bestimmt.
Maß
Weise einen Besucher einmal zu, bewahre die Zuweisung auf und melde sie zusammen mit deinen Umwandlungsereignissen.
Verbessern
Befördere den Gewinner auf die Standardposition und starte den nächsten Test von diesem aus.
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.
// 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);Du musst keine Analyseplattform in deinem Page Builder aufbauen. Du brauchst veröffentlichte Seiten, um die Ereignisse auszusenden, die dein bestehender Stack bereits versteht.
Feuer auf die Interaktionen, die wichtig sind – Form von Einsendungen, CTA-Klicks, Scrolltiefe auf langen Seiten.
Verknüpfe einen Beitrag mit der Seite, der Variante und der Kampagne, die sie hervorgebracht hat.
Die Basislinie jeder zweiten Zahl ist ein Verhältnis von .
Bewahren Sie UTM-Werte vom ersten Klick bis zum CRM-Datensatz.
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.
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.
Die Bearbeitungs-Engine. Selbstgehostet, BSD-3-Clause-Lizenz, kein gehosteter Dienst im Pfad.
Das JSON, als das deine Seiten gespeichert sind. Lesbar, unterschiedlich und dein zum Übertragen.
Was getHtml() und getCss() zurückgeben – das genaue Markup, das die Leinwand gerendert hat.
Auth, Versionierung, Berechtigungen und der Veröffentlichungsendepunkt. Der Teil, der tatsächlich dein Produkt ist.
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.
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ähigkeit | Von Grund auf | GrapesJS |
|---|---|---|
| Leinwand | Selbst bauen | Enthalten |
| Drag & Drop | Selbst bauen | Enthalten |
| Komponenten | Selbst bauen | Enthalten |
| Blöcke | Selbst bauen | Erweiterbar |
| Design | Selbst bauen | Enthalten |
| Responsive Bearbeitung | Selbst bauen | Enthalten |
| Vermögenswerte | Selbst bauen | Erweiterbar |
| Lagerung | Selbst bauen | Erweiterbar |
| Vorlagen | Selbst bauen | Erweiterbar |
| Plugin-Architektur | Selbst bauen | Enthalten |
| Formulare | Selbst bauen | Erweiterbar |
| SEO-Kontrollen | Selbst bauen | In deinen Stack integrieren |
| A/B-Tests | Selbst bauen | In deinen Stack integrieren |
| Veröffentlichung | Selbst bauen | In 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.
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.
Blöcke, Abschnitte und Vorlagen – was deine Nutzer ziehen und womit sie beginnen.
Durchsuchen-KategorieEin Startblock, auf dem du deine Landingpage-Sektionsbibliothek aufbaust.
Vorgefertigte Tailwind-Abschnitte – Hero, Features, Preise – für Teams, die bereits auf Tailwind setzen.
Ein konfigurierbarer Header-Abschnitt, der Block, mit dem jede Kampagnenseite beginnt.
Ein konfigurierbarer Fußbereich mit Navigations-, Rechts- und Vertrauenssignalen.
Gibt deinem Bauleiter einen Ort, um Kampagnenvorlagen zu speichern, aufzulisten und wieder zu öffnen.
Mehrseitige Projekte für Kampagnen, die mehr als eine URL benötigen.
Erfassung, Findbarkeit und Messung: die Teile, die eine Seite zu einer Kampagne statt zu einem Dokument machen.
Durchsuchen-KategorieEditierbare Formularkomponenten, die Nutzer nutzen können, können auf eine Seite fallen und auf Ihren Endpunkt zeigen.
In-Editor-Zugänglichkeit und SEO-Audits, sodass vor der Veröffentlichung Probleme auftauchen.
Führt Google Analytics in Seiten ein, die im Editor eingebaut sind.
Eine Countdown-Komponente für zeitgesteuerte Angebote, Starts und Webinare.
Bewegung, Typografie und die Komponenten, die eine Seite wie deine Marke aussehen lassen, statt wie ein Standardthema.
Durchsuchen-KategorieKarussells für Testimonials, Logo-Wolken und Screenshot-Galerien.
Animiertes Tippen für hero-Überschriften, ohne handgeschriebenes JavaScript auf der Leinwand.
Vereinfachte Steuerungen im Style-Manager für Übergänge, die sich designiert anfühlen.
Markentypografie im Editor, also sieht ein Marketer das, was ausgeliefert wird.
Wo sich das Projekt befindet, wie Assets aufgenommen werden und wie die Seite den Editor verlässt.
Durchsuchen-KategorieProjektliste und -management – die Ebene über einer einzelnen Bearbeitungssitzung.
Veröffentlicht direkt bei Netlify, für Teams, die am ersten Tag ein Hosting-Ziel wollen.
Exportiert die Seite als herunterladbares Archiv von HTML, CSS und Assets.
Er unterstützt den Asset Manager mit Cloudinary statt lokalen Uploads.
Drei Einkaufslisten, eingerahmt nach dem, was du baust, statt nach Katalogkategorie.
Für ein Marketingteam, das eigene Seiten veröffentlicht
Drag-and-Drop-MechanikFür ein Produktteam, das Seiten als Funktion errichtet, erstellen Sie Seiten als Funktion
Für eine Agentur, die ein System über Konten hinweg wiederverwendet
Die Preise werden beim Bau aus dem Katalog abgelesen und können sich geändert haben – die Produktseite ist maßgeblich.
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.
Jede Fähigkeit wird zu einem Ticket, einer Überprüfung und einer Wartungsvereinbarung.
Vier Schritte, pro Fähigkeit wiederholt, auf einer nicht geschriebenen Engine.
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
Wer den Editor öffnen kann und wessen Seiten er sieht, wenn er es tut.
Die Einheit, zu der ein Page gehört. Meistens dieselbe Einheit, zu der du abrechnest.
Bearbeiten, veröffentlichen und löschen sind drei verschiedene Rechte. Veröffentlichen ist das, was es wert ist, geschützt zu werden.
Seitenanzahl, Sitzplatzanzahl oder Veröffentlichungsvolumen – all das weiß der Editor gerne nicht.
Dein Chrome, deine Schriftarten, deine Symbole. Der Editor UI ist eine Konfiguration, keine feste Benutzeroberfläche.
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.
Das Problem einer Agentur ist nicht, einen einseitigen Builder zu bauen. Sie baut nicht dasselbe für den elften Kunden wieder auf.
Oder das des Kunden. Der Editor Chrome, die Icons und die Typografie können pro Tenant eingestellt werden.
Eine Sektionsbibliothek, einmal gepflegt, auf jedes Konto ausgeliefert.
Isolierte Projekte unter einer Installation, mit Assets und Vorlagen pro Kunde.
Starte einen neuen Kunden mit den Layouts, die beim letzten funktioniert haben.
Lass einen Kunden die Texte bearbeiten, ohne dass er die Seite umstrukturiert oder ungeprüft veröffentlicht.
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.
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:
Der Editor läuft in deiner Anwendung. Zwischen dir und deinen Nutzern gibt es keinen gehosteten Editor-Service.
Panels, Befehle und Komponententypen sind alle austauschbar, nicht nur thematisch.
Projektdaten befinden sich in Ihrer Datenbank, in einem Format, das Sie lesen und übertragen können.
Baue die Editor-Oberfläche, die deine Nutzer brauchen, statt die, die ein Anbieter ausliefert.
Ihr CRM, Ihre Asset-Speicherung, Ihr Deploy-Ziel – verdrahtet über das Plugin API.
Eine dokumentierte Plugin-Architektur und ein bestehender Katalog, auf den man zurückgreifen kann.
Nichts, was du baust, hängt davon ab, dass ein gehosteter Editor weiterhin zu seinen aktuellen Bedingungen existiert.
Ein Page Builder hat zwei sehr unterschiedliche Leistungsbudgets, und deren Verwechslung ist der häufigste Fehler in dieser Architektur.
Importiere es dynamisch, damit es nie in einem gemeinsamen Bundle landet.
Eine Editor-Instanz auf dem Autorenweg montierte clientseitige Version.
Der Editor besitzt sein eigenes DOM. Das Neurendern des Wrappers bei jedem Tastendruck bekämpft das.
Paginieren und den Asset Manager lazy laden, anstatt jeden Upload aufzulisten.
Lade ein Plugin, wenn das benötigte Panel geöffnet wird, nicht im Editor-Init.
Zwei Einstiegspunkte, zwei Budgets. Die veröffentlichte Seite sollte den Editor überhaupt nicht importieren.
Bilder, Schriftarten und kritische CSS im Output, abgestimmt wie jede andere Produktionsseite.
// 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.
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.
Endpunkte für Laden, Speichern und Veröffentlichen sind privilegiert. Behandeln Sie sie so.
Eine Seite bearbeiten zu dürfen ist nicht dasselbe wie sie veröffentlichen zu dürfen.
Überprüfe Typ, Größe und Inhalte auf Serverseite und serviere Nutzeruploads von einem Ursprungspunkt, den du isolieren möchtest.
Wo Seitenautoren nicht vollständig vertraut werden, desinfizieren Sie sowohl beim Hinausgehen als auch beim Einsteigen.
Project JSON, das bei deinem API ankommt, ist eine vertrauenswürdige Eingabe. Parse es, speichere es nicht einfach.
Das Veröffentlichen verändert, was die Öffentlichkeit sieht. Begrenze die Rate, logge es und mache es rückgängig.
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.
Drei Stufen, jeweils aussendbar. Der Fehler ist, zu versuchen, die dritte zu erreichen, bevor jemand eine Seite vom ersten veröffentlicht hat.
Eine Person kann eine Seite erstellen und veröffentlichen.
Ein Team kann sich darauf verlassen, auch wenn du nicht im Raum bist.
Der Bauunternehmer wird zu etwas, das du verkaufen kannst.
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.
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.
Installiere den Core, registriere deine erste Abschnittsbibliothek und lass eine Seite aus Projektdaten rendern.
Leg losFüge Blöcke, Vorlagen, Formulare, SEO-Auditing- und Veröffentlichungsziele hinzu, ohne sie selbst zu schreiben.
Durchsuchen von PluginsSagen Sie uns, was der Builder tun muss, und wir werden den Editor, den Plugin-Stack und die Integration scopen.
Baue deinen Landingpage BuilderBaue den Editor, den dein Produkt benötigt – anstatt die Editor-Engine von Grund auf neu zu bauen.