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

React-Seitenbauer

Baue einen React Page BuilderOhne den Editor von Grund auf neu zu bauen

Baue einen einbettbaren visuellen Seitenbauer mit React und GrapesJS. Beginne mit dem Open-Source-Editor-Kern und füge dann Blöcke, responsive Steuerungen, Speicher, Vorlagen und E-Mail-Funktionen über Plugins hinzu.

Open SourceSelbstgehostetEinbettbarErweiterbarReact & Next.js
your-app.com/editor
React

Blöcke

  • Held
  • Text
  • Bild
  • Knopf
  • Karte
  • Säulen

Deine Seite

Heldensektion
Der Editor, den Ihre Nutzer sehen – eingebaut in Ihrer eigenen React-Anwendung, auf Ihrer eigenen Domain.

26k+

GitHub-Sterne

100+

Plugins auf GJS.Market

1.4M+

npm-Downloads / Monat

$0

Lizenzgebühr für den Herausgeber

Sehen Sie es zuerst

Ein React-Seitenbauer, läuft

Vollbild öffnen

Der unveränderte Open-Source-Editor. Das ist die Grundlage, auf der alles andere auf dieser Seite aufbaut – Canvas, Blöcke, Stilmanager, Gerätewechsel, Rückgängig/Neumachen, Export.

grapesjs.com/demo.htmlKostenlos

Lädt einen Live-Editor von einer Drittanbieter-Demo-Seite. Nichts wird geladen, bis du danach fragst.

Definition

Was ist ein React Page Builder?

Ein React-Seitenbauer ist eine visuelle Bearbeitungsoberfläche, die in eine React-Anwendung eingebettet ist und es Nutzern ermöglicht, Seiteninhalte zu erstellen, zu verändern und zu anordnen, ohne HTML und CSS von Hand schreiben zu müssen.

Das wichtige Wort ist embedded. Ein React-Seitengenerator ist keine separate Website, die Ihre Nutzer besuchen – er ist ein Weg innerhalb Ihres Produkts, hinter Ihrem Login, in Ihre Datenbank.

Drei Schichten erledigen die Arbeit und gehören drei verschiedenen Eigentümern. Verwirrung ist der häufigste Grund, warum ein Seitenbau-Projekt ins Stocken kommt.

Anwendungsschicht

React / Next.js

Deine Anwendungsoberfläche, Authentifizierung, Routing, Abrechnung, Benutzer, Berechtigungen und APIs. Der Editor ist eine Route darin, nicht das gesamte Produkt.

Bearbeitungsebene

GrapesJS

Die visuelle Leinwand, Komponenten, Blöcke, Styling, Drag & Drop, Befehle und Serialisierung. Der Teil, der Monate zum Schreiben und Jahre zum Härten brauchen würde.

Persistenzschicht

Dein Backend

Projektspeicherung, Benutzer, Berechtigungen, Publizierung und Geschäftslogik. Der Editor gibt dir JSON und HTML; wohin es gehört und wer es sehen kann, ist deins.

Umfang

Ein React-Seiteneditor ist mehr als nur Drag & Drop

Eine Leinwand, auf die man eine Kiste legen kann, ist ein Wochenende. Alles darunter verwandelt diesen Prototyp in etwas, das man zahlenden Kunden präsentieren kann – und jeder Punkt auf der Liste ist ein Subsystem, das jemand bauen, testen und weiterarbeiten muss.

  • Visuelle Leinwand — GrapesJS-Kern
  • Komponenten — GrapesJS-Kern
  • Blöcke — GrapesJS-Kern
  • Drag & Drop — GrapesJS-Kern
  • Style Manager — GrapesJS-Kern
  • Responsive Bearbeitung — GrapesJS-Kern
  • Vermögenswerte — GrapesJS-Kern
  • Rich Text — GrapesJS-Kern
  • Rückgängig machen / neu machen — GrapesJS-Kern
  • Lagerung — GrapesJS-Kern
  • Geräte — GrapesJS-Kern
  • Export — GrapesJS-Kern
  • Plugin-System — GrapesJS-Kern
  • Seiten — Plugins
  • Vorlagen — Plugins
  • Berechtigungen — Ihr Antrag
  • Verlagswesen — Ihr Antrag
Wer baut esIhr AntragGrapesJS-KernPlugins

Den ersten Drag-and-Drop-Prototyp zu bauen ist relativ einfach. Alles drumherum zu bauen, was einen Editor in der Produktion zuverlässig macht, ist der teure Teil.

Bauen vs. adoptieren

Warum den Editor von Grund auf neu bauen?

Es gibt einen guten Grund, deinen eigenen Editor zu schreiben: Dein Bearbeitungsmodell ist wirklich anders als alles, was es gibt. Abgesehen davon verlangt jeder der drei Wege tatsächlich von deinem Team.

Option A

Von Grund auf neu bauen

Du besitzt jede Schicht, auch die, die nichts mit deinem Produkt zu tun haben.

Du implementierst und pflegst

  • Leinwand und Auswahl
  • Drag & Drop mit Verschachtelungsregeln
  • Komponentensystem
  • Blockpalette
  • Style Manager
  • Reaktionsschnelle Steuerung
  • Vermögensverwaltung
  • Rich Text Editing
  • Geschichte rückgängig machen / neu machen
  • Speicherung und Autosave
  • HTML / CSS-Export
  • Vorlagen und Seiten
  • Cross-Browser-Tests
  • Laufende Wartung

Jedes dieser Systeme ist ein Subsystem, das sich zurücksetzen kann, und keines davon unterscheidet dein Produkt.

Option B

Fang mit GrapesJS an

Übernehmen Sie eine Bearbeitungsgrundlage und bauen Sie Ihre Anwendung darum herum.

Du implementierst

  • Montage des Editors in deiner React-App
  • Die Blöcke, die Ihr Produkt benötigt
  • Speicher gegen deine eigene API
  • Veröffentlichung deiner Redaktionsarbeiten
  • Deine eigene Benutzeroberfläche rund um die Leinwand

Der Editor hört auf, ein Projekt zu sein. Es wird zu einer Abhängigkeit, die du konfigurierst.

Siehe den Code
Option C

Erweitern Sie mit GJS.Market

Fügen Sie spezialisierte Funktionen hinzu, ohne die Editor-Architektur zu beeinflussen.

Du installierst

  • Blöcke, Presets und Vorlagen
  • Seiten und Projektmanagement
  • Speicheradapter
  • E-Mail- und MJML-Support
  • Responsive und SEO-Tools

Die Features, die du als Nächstes geschrieben hättest, sind bereits veröffentlicht, bepreist und einsetzbar.

Plugins durchsuchen

Baue keinen visuellen Editor von Grund auf. Baue dein React-Produkt auf einer bewährten Editor-Grundlage auf.

Der Stapel

GrapesJS + React + Plugins = Ihr Page Builder

Jede Ebene hat eine Aufgabe. Halte sie getrennt, und das Ganze bleibt austauschbar – einschließlich des Editors, was der Sinn eines Standard-Editors ist.

Editor-Engine

GrapesJS

Leinwand, Komponenten, Blöcke, Stile, Befehle, Serialisierung. Open Source, selbstgehostet, keine Lizenzgebühr.

Plus
Anwendungsschicht

React / Next.js

Dein Dashboard, deine Authentifizierung, das Routing, die Abrechnung und die APIs. Der Editor ist eine Route innerhalb deiner App.

Plus
Funktionalitätsschicht

GJS.Market

Die Funktionen, die Sie sonst als Nächstes bauen würden – Seiten, Vorlagen, Speicher, E-Mail, SEO.

gleich
Ihr Produkt

Dein React-Seiten-Builder

  • SaaS-Seitenbauer
  • Website-Builder
  • CMS-Visual-Editor
  • Landingpage-Builder
  • E-Mail-Builder
Fang mit dem Code an
Ergebnisse

Was kann man mit einem React Page Builder bauen?

Der gleiche Editor-Kern, der auf fünf verschiedene Produkte zeigte. Was sich zwischen ihnen ändert, sind die Blöcke, das Speichermodell und die Ausgabe – nicht der Editor.

Architektur

Wie React und GrapesJS zusammenarbeiten

Der Editor ist eine Komponente, kein Ziel. Sie wird in einer Route installiert, die Sie bereits besitzen, neben dem Rest Ihrer Anwendung. Ihre Nutzer verlassen Ihr Produkt nie, Ihre Sitzung ist bereits gültig, und der produzierte Inhalt geht direkt in Ihre Datenbank.
  1. React / Next.js
  2. GrapesJS
  3. Your backend

Das ist der Teil, der Teams überrascht, die gehostete Plattformen bewerten: Es gibt kein zweites System, das synchron gehalten werden muss, weil es kein zweites System gibt.

Die Daten fließen nach unten: Deine App mountet den Editor, der Editor gibt ein Projekt zurück, dein Backend speichert es.

Vergleich

Vergleich des React Page Builders

Fünf Werkzeuge, die sich alle als visuelle Editoren für React beschreiben und nicht austauschbar sind. Jede Zelle unten stammt aus der eigenen Dokumentation jedes Projekts oder den Metadaten des veröffentlichten Pakets.

LeistungsfähigkeitGrapesJSPuckCraft.jsBuilder.ioPlasmic
React-IntegrationOffizielle VerpackungReact-native APIReact-native APIReact SDKReact SDK + Codegen
LizenzBSD-3-Clause core, MIT React wrapperMITMITMIT SDK, hosted platformMIT
Selbst den Redakteur selbst moderieren✓ — läuft vollständig in deiner App✓✓— gehostete PlattformTeilweise – Studio-Selfhosting ist dokumentiert
Integrieren Sie Ihre eigene App-Benutzeroberfläche✓✓✓Über IntegrationUnternehmen — Whitelabelling & Embedding
Visuelle Leinwand✓✓ — iframe gleicher Herkunft✓ — du lieferst die umgebende Benutzeroberfläche✓✓
Drag & Drop✓✓✓✓✓
Individuelle Komponenten✓ — benutzerdefinierte Bauteiltypen✓ — Konfiguration + Renderfunktion✓ — Benutzerkomponenten✓ — registrierte Komponenten✓ — Codekomponenten
Deine React-Komponenten wurden auf der Leinwand gerendertÜber Integration – die Leinwand rendert DOM✓ — gebürtig✓ — gebürtig✓✓
Fertiges Editor-UI✓ — Standard-UI enthalten✓— du baust die Benutzeroberfläche✓ — gehostete Benutzeroberfläche✓ — Hoststudio
Style-Manager für beliebige CSS✓ — Style ManagerGepflogenheitGepflogenheit✓✓
Responsive / Viewport-Bearbeitung✓ — Gerätemanager✓ — SichtfensterGepflogenheit✓✓
Persistiere in deiner eigenen Datenbank✓ — Storage Manager + benutzerdefinierte Adapter✓ — Sie besitzen die Daten✓ — Fortsetzung an JSON— Inhalt lebt in BuilderKommt darauf an – Projekte befinden sich in Plasmic
HTML / CSS-Export✓ — getHtml() / getCss()GepflogenheitGepflogenheitKommt darauf an✓ — CodeGen
Plugin-Ökosystem✓ — GJS.Market, 100+ plugins✓ — Plugin API—✓✓
White-Label✓✓✓Kommt auf den Plan anUnternehmen
E-Mail (MJML / Newsletter)✓ — MJML & Newsletter-VoreinstellungenGepflogenheitGepflogenheit— E-Mail-Modelle veraltet—
Embed für deine eigenen Endkunden✓✓✓Kommt auf den Plan anUnternehmen
Neueste Veröffentlichung0.23.6 · 2026-08-250.23.0 · 2026-08-070.2.12 · 2025-02-149.4.4 · 2026-09-022.0.26 · 2026-09-02

✓ = dokumentierte Fähigkeit. Benutzerdefiniert = unterstützt, aber Sie implementieren sie. Über Integration / Hängt / Enterprise = verfügbar unter den vom Anbieter festgelegten Bedingungen. — = nicht angeboten oder nicht als Fähigkeit des Produkts selbst dokumentiert.
2026-09-02 wurde anhand der offiziellen Dokumentation jedes Projekts, der Metadaten des npm-Registers und des GitHub-Repositoriums überprüft. Produktfähigkeiten und Preise ändern sich im Laufe der Zeit – prüfen Sie die aktuelle Dokumentation, bevor Sie eine architektonische Entscheidung treffen.

Auswahl

Welchen React Page Builder solltest du wählen?

Keine dieser Fragen ist universell besser. Sie sind Antworten auf verschiedene Fragen, und die Frage, die du tatsächlich stellst, ist meist offensichtlich, sobald sie aufgeschrieben ist.

Ehrliche Passung

Wann GrapesJS passt – und wann es nicht passt

Drei Ergebnisse, von denen eines nicht GrapesJS ist. Wenn eine Vergleichsseite dir nicht sagen kann, wann du weggehen sollst, ist sie kein Vergleich.

Gute Passform

Du baust ein Produkt, und das Bearbeiten ist ein Feature davon.

Der Redakteur lebt hinter deinem Login, schreibt in deine Datenbank und trägt dein Branding. Du erwartest, dass du es jahrelang weiter ausdehnst.

  • Self-Hosting ist eine Voraussetzung, keine Präferenz
  • Du brauchst HTML/CSS-Ausgaben, die du überall rendern kannst
  • Der Redakteur wird schließlich Seiten, Vorlagen oder eine E-Mail benötigen
  • Du willst eine Plugin-Oberfläche statt eines Forks
Schau woanders hin

Deine Bearbeitungseinheit ist eine React-Komponente, keine Seite

Wenn Nutzer Instanzen von bereits ausgelieferten Komponenten konfigurieren und freies Styling ausdrücklich nicht gewünscht ist, fühlt sich ein React-First-Editor natürlicher an als ein allgemeiner visueller Editor.

  • Bearbeiten bedeutet, getippte Requisiten auszufüllen, nicht Kisten zu verschieben
  • Dein Designsystem ist die Einschränkung, bewusst
  • Du brauchst überhaupt kein beliebiges CSS
Noch nicht

Du bist dir nicht sicher, was deine Nutzer bearbeiten werden

Das Inhaltsmodell bestimmt den Editor, nicht umgekehrt. Einen Editor auszuwählen, bevor man weiß, was eine "Seite" in deinem Produkt ist, ist der häufigste Weg, wie diese Projekte umgeschrieben werden.

  • Schreiben Sie auf, was ein Nutzer erschaffen kann und was er nicht kann
  • Entscheide, wo Inhalte zu finden sind, bevor du entscheidest, wie sie bearbeitet werden
  • Prototypen mit dem freien Kern, bevor Sie sich festlegen
Implementierung

Baue deinen ersten React Page Builder

Zwei Pakete und eine Komponente. Der Wrapper bündelt die Kernbibliothek nicht, also installieren Sie beide. Das untenstehende Beispiel läuft wie beschrieben – der @grapesjs/react-Wrapper verlangt, dass der Core explizit weitergegeben wird, was der Schritt ist, den die meisten Drittanbieter-Tutorials weglassen.

npm i grapesjs @grapesjs/react
components/page-builder.tsxtsx
'use client';

import grapesjs, { type Editor } from 'grapesjs';
import GjsEditor from '@grapesjs/react';
import 'grapesjs/dist/css/grapes.min.css';

export default function PageBuilder() {
  const onEditor = (editor: Editor) => {
    // The full GrapesJS API is yours from here: Blocks, Pages,
    // DeviceManager, Commands, StorageManager.
    editor.Blocks.add('hero', {
      label: 'Hero',
      category: 'Sections',
      content: '<section class="hero"><h1>Headline</h1></section>',
    });
  };

  return (
    <GjsEditor
      // Required. The wrapper does not bundle the core library.
      grapesjs={grapesjs}
      options={{
        height: '100vh',
        // Persistence is wired separately — see the storage step below.
        storageManager: false,
      }}
      onEditor={onEditor}
    />
  );
}

Was jedes Stück bewirkt

Leinwand

Die visuelle Bearbeitungsfläche. Sie rendert DOM innerhalb eines iframes, weshalb Styles nicht aus deiner Anwendung gelangen können.

Blöcke

Die Palette, aus der Nutzer ziehen. Registrieren Sie hier die Bereiche Ihres Produkts, und sie werden zu bearbeitbaren Inhalten.

Lagerung

Persistiere Projekte auf deinem eigenen Backend. Lokale und entfernte Adapter sind eingebaut; benutzerdefinierte Adapter benötigen eine Last und eine Speichermethode.

Plugins

Die Erweiterungsoberfläche. Alles von Tailwind-Blöcken bis zu MJML-E-Mails kommt auf diese Weise an, ohne den Editor zu forken.

Speichern Sie Projekte in Ihrer eigenen Datenbank

Speicher ist der Ort, an dem Prototypen enden und Produkte beginnen. GrapesJS liefert lokalen und entfernten Speicher aus und ermöglicht es Ihnen, einen vollständig individuellen Adapter mit zwei asynchronen Methoden zu registrieren – sodass der Editor nie wissen muss, wie Ihr Backend aussieht.

storage.tsts
// Persist projects to your own API. GrapesJS ships `local` and `remote`
// storage; `Storage.add` registers a fully custom adapter.
// Docs: grapesjs.com/docs/modules/Storage.html

const onEditor = (editor: Editor) => {
  editor.Storage.add('api', {
    async load() {
      const res = await fetch(`/api/pages/${pageId}`);
      return res.json(); // → the project JSON GrapesJS restores from
    },
    async store(project) {
      await fetch(`/api/pages/${pageId}`, {
        method: 'PUT',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(project),
      });
    },
  });
};

// …then point the editor at it:
options={{
  storageManager: { type: 'api', autosave: true, stepsBeforeSave: 5 },
}}

Editor-Ausgabe in eine Live-Seite verwandeln

Der Editor gibt HTML und CSS zurück. Was man damit macht, ist eine Anwendungsentscheidung: Sie rendern sie von einer Next.js-Route, pushen Sie sie auf ein CDN oder senden Sie sie als E-Mail. Der Editor befindet sich nicht im Serving Path.

publish.tsts
// Editor output → a production page.
// getHtml/getCss return the exact markup the canvas rendered.

const html = editor.getHtml();
const css = editor.getCss();

await fetch('/api/publish', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ slug, html, css }),
});

// Your app renders it wherever you control — a Next.js route, a CDN
// object, an email send. The editor is not in the serving path.

Verifiziert mit @grapesjs/react 0.23.6, das auf React 18/19 und Next.js 15 abzielt. Ein Hinweis, den man früh wissen sollte: Der React-Wrapper baut dein UI around auf der Leinwand – er rendert deine React-Komponenten nicht inside darauf. Wenn das Rendern von lebenden React-Komponenten auf der Leinwand eine harte Voraussetzung ist, ist ein React-First-Editor die bessere Wahl, und diese Seite sagt das auch im obigen Vergleich.

Next.js

Mit Next.js?

Behalte den Redakteur beim Kunden. React-Seitenentwickler sind üblicherweise in Next.js-Anwendungen eingebettet. Der Editor ist nur clientsbasiert; Ihre Anwendung übernimmt weiterhin die Authentifizierung, APIs, Routing und alles Serverseitige.
  1. Next.js App
  2. Route: /editor
  3. Client component
  4. GrapesJS
app/editor/page.tsxtsx
// app/editor/page.tsx — the editor is client-only.
// GrapesJS measures the DOM on init, so it must never render on the server.
import dynamic from 'next/dynamic';

const PageBuilder = dynamic(() => import('@/components/page-builder'), {
  ssr: false,
  loading: () => <EditorSkeleton />,
});

export default function EditorRoute() {
  // Auth, params and data fetching stay on the server side of your app.
  return <PageBuilder />;
}

Praktische Anmerkungen

  • Importiere den Editor mit 'dynamic(..., { ssr: false })'. GrapesJS misst den DOM auf init, sodass das Serverrendern Hydration Mismatches erzeugt.
  • Rendere ein Skelett im 'Laden'-Slot. Das Editor-Bündel ist groß und die Route ansonsten blinkt leer.
  • Behalten Sie Auth, Params und Datenabruf auf der Serverseite der Route; leiten Sie die Ergebnisse als Props weiter.
  • Halte die Editor-Instanz aus 'onEditor' in einer Referenz, nicht in einem State – wenn man sie in State schreibt, rendert der Baum bei jedem Editor-Event erneut.
  • Lazy-Load-Plugins, die du beim ersten Malen nicht brauchst. Die meisten Editoren brauchen sofort Blöcke und MJML nie.

Der Editor ist ein Blatt des Baumes, nicht der Stamm.

Fahrplan

Vom Prototyp zur Produktion

  1. 1
    01

    Mounten Sie den Herausgeber.

    Integriere GrapesJS in eine Route in deiner React-Anwendung. An diesem Punkt hast du eine funktionierende Leinwand und die Standard-Benutzeroberfläche – eine Tagesarbeit, nicht ein Quartal.

  2. 2
    02

    Definieren Sie Ihr Inhaltsmodell

    Entscheide, was eine Seite in deinem Produkt ist, was Nutzer erstellen dürfen und was sie nicht anfassen dürfen. Diese Entscheidung beschränkt alles danach, also triffe sie, bevor du Blöcke schreibst.

  3. 3
    03

    Blöcke und Komponenten hinzufügen

    Verwandle die Abschnitte deines Produkts in Blöcke und benutzerdefinierte Komponententypen. Hier fühlt sich der Editor wie Teil deines Produkts an, statt wie ein generisches Werkzeug.

  4. 4
    04

    Verbindungsspeicher

    Registrieren Sie einen Speicheradapter gegen Ihre eigene API, mit Autosave und Wiederherstellung. Projekte gehören jetzt den Nutzern, und Entwürfe überdauern einen geschlossenen Tab.

  5. 5
    05

    Veröffentlichen

    Wandeln Sie gespeicherte Projekte in Produktionsseiten um – eine Next.js-Route, ein CDN-Objekt, eine E-Mail-Sendung. Der Editor bleibt aus dem Bereitstellungspfad heraus.

Erweitern

Vielleicht brauchst du keinen anderen Page Builder

Die meisten "Wir müssen unseren Redakteur ersetzen"-Gespräche drehen sich um eine fehlende Fähigkeit. Einen Redakteur zu ersetzen kostet ein Viertel; das Hinzufügen einer Fähigkeit kostet einen Nachmittag.

Ersetze den Editor nicht, nur weil ein Feature fehlt. Erweitere den Editor.

Marktplatz

Erweitern Sie Ihren React Page Builder mit GJS.Market

Beginnen Sie mit dem Editor-Kern und fügen Sie die Funktionalität hinzu, die Ihr Produkt tatsächlich benötigt. Preise, Namen und Thumbnails stammen direkt aus dem Katalog, sodass hier nichts von dem zum Verkauf stehenden Dinge abweichen kann.

Stapel

Baue deinen React Page Builder Stack auf

Drei Einkaufslisten statt eines Katalog-Dumps. Jede einzelne entspricht dem, was ein funktionierender Build dieses Produkts über den freien Kern hinaus benötigt.

Live-Katalogpreise. Ein Stapel ist ein Vorschlag, kein Bündel – kaufen Sie die benötigten Teile.

Gesamtkosten

Was kostet es, einen React Page Builder zu erstellen?

Die Editor-Lizenz ist selten die Zahl, die zählt. Das sind die Kostenstellen, die jede Route schafft – absichtlich ohne erfundene Zahlen, denn die Preise und der Umfang Ihres Teams sind die einzigen Inputs, die eine Zahl real machen würden.

Von Grund auf neu bauen

Du zahlst für den Editor für immer

Der Anfangsbau ist die kleinere Hälfte.

Kostenstellen

  • Editor-Architektur und Design
  • Implementierung über jedes Subsystem hinweg
  • Editor UX, was eine eigene Disziplin ist
  • Cross-Browser- und Regressionstests
  • Fehlerbehebung in Code, der nicht dein Produkt ist
  • Integrationen, sobald Anforderungen eintreffen
  • Laufende Wartung, auf unbestimmte Zeit

Jede zukünftige Feature-Anfrage landet bei dem Team, dem der Editor gehört – also dir.

Verwende GrapesJS

Man bezahlt für Integration, nicht für Erfindung

Der Redakteur kommt; die Produktarbeit bleibt.

Kostenstellen

  • Integration in deine React-App
  • Anpassung an Ihr Designsystem
  • Backend- und Speicherverkabelung
  • Ihre produktspezifischen Funktionen

Keine Lizenzgebühr für den Kern, und die Wartung im Vorstrom ist die Aufgabe von jemand anderem.

Plugins hinzufügen

Du zahlst pro Fähigkeit, einmal

Kauf die Features, die du gerade planen wolltest.

Kostenstellen

  • Einmalige Kosten pro Plugin, zum Katalogpreis
  • Konfiguration statt Konstruktion
  • Keine Mitarbeiterzahl ist mit der Fähigkeit verbunden

Jedes Plugin entfernt eine Zeile aus der Roadmap, anstatt eine hinzuzufügen.

Siehe Katalogpreise

Der teure Teil eines Page Builders ist nicht die erste Demo. Es ist alles, was nötig ist, um den Editor produktionsbereit zu machen.

Arbeitsteilung

Baue dein Produkt. Nicht deine Editor-Infrastruktur.

Hier ist das gesamte Argument auf einem Bildschirm. Die linke Spalte zeigt Arbeit, die nur du machen kannst, weil sie dein Produkt ist. Die anderen beiden sind bereits existierende Arbeiten.

Deine App und Backend
  • AuthentifizierungWer eingeloggt ist und als wer.
  • AbrechnungPläne, Limits und Rechnungen.
  • Benutzer & BerechtigungenWer welches Projekt bearbeiten darf.
  • DatenbankWo Projekte und Seiten tatsächlich stehen.
  • VerlagswesenGespeicherte Inhalte in eine Live-URL umwandeln.
GrapesJS
  • Leinwand & AuswahlDie Schnittfläche und alles, was darauf ist.
  • Blöcke & Drag-DropDie Palette und die Sortierregeln.
  • Style ManagerCSS pro Komponente, pro Breakpoint.
  • KomponentensystemTypisierte Elemente mit Eigenschaften und Serialisierung.
  • Redaktion & GeschichteRich Text, rückgängig/wiederholen, Befehle.
GJS.Market
  • E-Mail-AusgabeMJML und Newsletter-Presets.
  • Vorlagen & SeitenWiederverwendbare Ausgangspunkte, mehrseitige Projekte.
  • SEO & BarrierefreiheitPrüfung, bevor die Seite online geht.

Der teure Teil eines Seitenbauers ist nicht die erste Demo. Es ist alles, was nötig ist, um den Redakteur produktionsreif zu machen – und fast nichts davon ist das, wofür Ihre Kunden Sie bezahlen.

Zielgruppe

Wer baut React-Seiten-Builder?

Vier Teams kommen mit derselben Anforderung und sehr unterschiedlichen Einschränkungen auf diese Seite.

SaaS-Gründer

Sie benötigen einen visuellen Editor innerhalb Ihres Produkts, auf Ihrer Domain, unter Ihrem Branding – und Sie können Kunden nicht zu einer Drittanbieterplattform schicken, um ihre eigenen Inhalte zu bearbeiten.

Produktteams

Visuelles Bearbeiten ist ein Feature auf einer Roadmap voller solcher Karten. Man braucht es, um es auszuliefern, ohne ein dauerhaftes internes Plattformteam zu werden.

Agenturen

Man baut dieselbe Bearbeitungsfläche für Client um Kunde auf. Eine wiederverwendbare, selbsthostbare Grundlage ist mehr wert als jedes einzelne Projekt.

Entwickler

Man möchte einen erweiterbaren Editor-Kern und volle Kontrolle über die umliegende Anwendung, ohne die Produktentscheidungen anderer zu übernehmen.

Entscheidung

Finden Sie den richtigen React-Seitenbauer

Drei Fragen. Zwei der vier Antworten sind nicht GrapesJS.

Muss der visuelle Editor in deiner eigenen Anwendung integriert werden?

Jeder Weg auf einen Blick

  • Muss der visuelle Editor in deiner eigenen Anwendung integriert werden? Ja, in meiner App, dann Ist das, was Nutzer bearbeiten, immer eine deiner bestehenden React-Komponenten? Ja, nur KomponentenErgebnis: Betrachten wir Puck
  • Muss der visuelle Editor in deiner eigenen Anwendung integriert werden? Ja, in meiner App, dann Ist das, was Nutzer bearbeiten, immer eine deiner bestehenden React-Komponenten? Nein, sie bearbeiten Seiten und Layout, dann Möchtest du die gesamte Editor-Oberfläche selbst entwerfen und bauen? Ja, ich werde die Benutzeroberfläche bauenErgebnis: Betrachten wir Craft.js
  • Muss der visuelle Editor in deiner eigenen Anwendung integriert werden? Ja, in meiner App, dann Ist das, was Nutzer bearbeiten, immer eine deiner bestehenden React-Komponenten? Nein, sie bearbeiten Seiten und Layout, dann Möchtest du die gesamte Editor-Oberfläche selbst entwerfen und bauen? Nein, ich möchte eine Editor-UI eingebaut habenErgebnis: GrapesJS passt
  • Muss der visuelle Editor in deiner eigenen Anwendung integriert werden? Nein, ein gehostetes Tool ist in OrdnungErgebnis: Betrachten Sie eine gehostete Plattform
Vergleiche

Vergleiche die React Page Builder Frameworks

Jede davon geht deutlich tiefer als die obige Matrix – Datenmodelle, Migrationspfade und die Fälle, in denen das andere Tool gewinnt.

FAQ

Fragen zum React Page Builder

Leg los.

Baue deinen React Page Builder

Beginnen Sie mit GrapesJS, integrieren Sie es mit React und erweitern Sie Ihren Editor um die Funktionalität, die Ihr Produkt benötigt.

Entwickler

Beginnen Sie mit dem Bau

Öffne einen Live-Editor, nutze dann den Quick-Start und mounte einen in deiner eigenen React-App.

Probier GrapesJS
Erweitern

Füge hinzu, was dir fehlt.

Blöcke, Seiten, Vorlagen, Speicheradapter, MJML-E-Mail und SEO-Tools – bepreist nach Funktionalität.

Durchsuchen Sie GJS.Market-Plugins
Produktteam

Brauchst du Hilfe?

Architektur-Review, ein benutzerdefinierter Editor-Build oder eine zweite Meinung, bevor du dich für einen Stack entscheidest.

Sprich mit einem GrapesJS-Experten

Baue dein Produkt. Nicht deine Editor-Infrastruktur.