Create
Build pages using drag-and-drop blocks, without writing markup or opening a support ticket.
PageKit — the self-hosted GrapesJS site builder, sold as source. Get early access
Give your customers a drag-and-drop visual editor without spending months building editor infrastructure from scratch.
26k+
GitHub stars
100+
Plugins on GJS.Market
10 years
Active development
$0
License fee, always
This is what the end user of your SaaS actually gets — the part they see, use and stay for.
Build pages using drag-and-drop blocks, without writing markup or opening a support ticket.
Edit layouts, content, typography, colors and spacing directly on the canvas.
Save drafts and projects into your infrastructure, under your own accounts and permissions.
Check a page across breakpoints before anything reaches a live audience.
Connect publishing to the workflow you already run — your domains, your CDN, your release rules.
Start from templates and reusable components instead of an empty canvas every time.
Your customers get a visual editing experience without leaving your SaaS.
A visual editor looks like one feature on a roadmap. It is not. Each of these is a subsystem your team would own, test and maintain for as long as the product lives.
What a page builder actually contains
Your team builds and maintains every editor feature above, and keeps maintaining them while the rest of the roadmap waits.
Use an open-source editor for the core and extend it with ready-made plugins, so your engineering time goes into what makes your SaaS different.
Spend your engineering time on your SaaS — not on rebuilding an editor.
Customer logs into your SaaS
Your existing auth, your existing dashboard. Nothing about the account model changes.
Creates a new page
A record in your database, scoped to that customer and their plan.
Chooses a template
A curated starting point beats a blank canvas — and keeps output on-brand.
Opens the visual editor
The editor mounts inside your product shell. The customer never leaves your SaaS.
Edits content and design
Blocks, styles and responsive breakpoints, all on the canvas.
Saves a draft
Autosave writes to your API on your schedule, not to a third-party service.
Previews
A render of the real output, before anything is public.
Publishes
Your publish endpoint runs whatever your workflow requires — approvals, versioning, cache invalidation.
Live customer page
Served from your infrastructure, on your domain, counted against your plan limits.
Build the editing experience into your existing customer workflow rather than bolting a separate tool onto the side of it.
Three public GrapesJS builds, loaded only when you ask for them. Nothing here is a video — it is the real editor.
The official demo — the open-source editor with no preset applied. This is the baseline your SaaS would start from.
Loads a third-party demo page in an iframe. Nothing is requested until you click.
The same editor core supports very different products. Pick the one closest to yours.
Let customers create conversion-focused landing pages without waiting on your design team.
Landing page builderGive users the tools to build and manage complete multi-page websites inside your platform.
Website builderLet customers assemble campaigns and branded pages that stay within the rules you set.
Marketing pagesGive content teams visual editing on top of the content model you already run.
Visual CMSAdd visual email creation to your SaaS, with MJML output that survives real inboxes.
Explore email builderGenerate a first draft with AI, then let users refine it visually instead of re-prompting.
AI pluginsKeep your structured backend and add a visual editing layer on top of it.
Headless setupThe editor is one layer, not the system. Everything that matters commercially — accounts, data, limits, publishing — stays yours.
Your SaaS owns
GrapesJS provides
Your backend owns
Want the integration detail rather than the shape? Read the embeddable page builder guide
Templates & permissions
Define what users can create and which features each plan or role can access. This is the layer that later becomes your pricing.
Storage & media
Connect projects and assets to your own APIs and storage, so customer content never lives somewhere you don't control.
Draft → preview → publish
Create a publishing workflow that fits your SaaS, including whatever review or versioning your customers expect.
Analytics
Track adoption, editor usage and customer engagement so you can tell whether the feature is earning its keep.
Start with the editor core. Build your SaaS-specific functionality around it.
Two steps to a working editor. Everything after this is your product, not editor plumbing.
npm install grapesjsimport grapesjs from 'grapesjs';
import 'grapesjs/dist/css/grapes.min.css';
// The editor core. Mount it anywhere inside your customer dashboard.
const editor = grapesjs.init({
container: '#editor',
});And here is the part that makes it a SaaS feature rather than a demo — persistence and publishing pointed at your own API:
const editor = grapesjs.init({
container: '#editor',
// Each customer's page is a row in your database, behind your own auth.
storageManager: {
type: 'remote',
autosave: true,
options: {
remote: {
urlStore: `/api/customers/${customerId}/pages/${pageId}`,
urlLoad: `/api/customers/${customerId}/pages/${pageId}`,
fetchOptions: { credentials: 'include' },
},
},
},
});
// Publishing stays on your side — your domains, your CDN, your workflow.
async function publish() {
await fetch(`/api/customers/${customerId}/pages/${pageId}/publish`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ html: editor.getHtml(), css: editor.getCss() }),
});
}This is the editor core. Add the functionality your SaaS needs through plugins and your own integrations.
Every listing below is a real product on GJS.Market, priced live from the catalogue. Where a capability is part of the GrapesJS core rather than a plugin, it is described in the architecture section above instead of sold to you here.
Replace the default editor shell with a reworked interface that stops looking like a generic tool.
A modern preset to start from when the stock editor UI does not fit your product.
Four starting combinations, priced live. Each one is GrapesJS plus the plugins that particular product actually needs.
Blocks + templates + storage + export
Build a landing page builderBlocks + pages + assets + storage
Build a website builderTemplates + storage + assets + pages
Build a visual CMSMJML + email blocks + templates + export
Prices come from the live catalogue and can change. Free plugins stay free.
What changes for your product once customers can edit for themselves.
Customers can make content changes themselves instead of opening a ticket for a headline.
Less dependency on developers for simple layout and copy changes.
Visual editing is a capability prospects can see in a demo, which makes it a real differentiator.
Customers who build content inside your platform have more reason to stay in it.
Advanced editing functionality gives higher plans something concrete to contain.
Effects vary by product and audience — treat these as the mechanisms to measure, not guaranteed outcomes.
One way to package editing across plans. This is an illustration of the shape, not a recommendation of specific prices.
Templates and core editing.
Advanced blocks and additional functionality.
Advanced permissions and collaboration.
Custom integrations and advanced workflows.
Example SaaS packaging. Your pricing model can be built around the features and workflows your customers need.
The page builder doesn't have to be just a feature — it can increase the value of your SaaS plans.
The same decision looks different depending on where you sit.
Launch an MVP without building an editor from scratch or hiring for it.
Keep control of architecture, data and infrastructure while removing a large build from the roadmap.
Add visual editing as a product capability with a path you can scope and ship.
Start from an extensible editor with documented APIs instead of a blank canvas.
Build one editing system and reuse it across multiple client products.
GrapesJS is framework-agnostic — it mounts on a DOM container, so it fits whatever you already run.
Official @grapesjs/react wrapper, MIT licensed, for idiomatic component integration.
React page builderClient-side only — load the editor with a dynamic import so it never runs during SSR.
Next.js page builderMount on a template ref and tear the editor down on unmount.
Vue page builderInitialize from a ViewChild element reference inside the component lifecycle.
Angular builderNo framework at all — a script tag and a container element is the whole integration.
HTML drag & drop builderThis page covers the product decision. Two neighbouring guides go deeper on the parts it only touches.
The honest version: you are not avoiding all the work, you are avoiding the part that is identical in every page builder ever written.
| Layer | Build from scratch | GrapesJS + GJS.Market |
|---|---|---|
| Editor core | Build | Ready |
| Canvas | Build | Ready |
| Blocks | Build | Plugins |
| Storage | Build | Connect your API / plugins |
| Assets | Build | Extend |
| UI | Build | Customizable |
| Publishing | Build | Your workflow |
| Maintenance | Your team | Open ecosystem |
| Time to MVP | Months | Start in days |
"Start in days" describes standing up a working editor, not shipping a finished product — your SaaS-specific work still takes as long as it takes.
Everything on this page points at something you can inspect yourself. Figures verified 2026-08-27.
The grapesjs core is on GitHub with 26k+ stars and a public issue tracker. Read it before you commit to it.
The core is BSD-3-Clause and the official React wrapper is MIT. Both permit commercial use, with no royalties and no per-seat fee.
100+ plugins on GJS.Market, plus published packages on npm — every listing on this page links to the product it names.
The demos above are public deployments. Load one, break it, then decide.
Three ways forward, depending on how much of this you want to do yourself.
Assemble the stack for your product from real listings — storage, blocks, templates, export.
Browse pluginsInstall the open-source core and mount your first editor. Free, and no commitment to anything.
Read the tutorialHave the editor, storage and publishing wired into your SaaS by people who have done it before.
GrapesJS integration services