Try the demoGet Started

For developers

Built on Node.js, Express, and a modular architecture, ApostropheCMS gives developers the freedom to build custom digital experiences without fighting the CMS. Your code and frontend stay yours. Your content stays manageable.

What makes ApostropheCMS a JavaScript-native CMS?

ApostropheCMS was built for JavaScript teams from the beginning — not ported from another ecosystem and not wrapped around someone else's architecture. Your application, your CMS customization, and your frontend all live in the same ecosystem. The module system gives you a clean way to extend functionality, keep your code organized, and upgrade without maintaining a fork. If your team already builds with Node.js, ApostropheCMS feels familiar.

  • Why Node.js at the core matters

    Build with the language, tooling, and patterns your team already knows.

    • One JavaScript ecosystem across your application stack
    • Familiar Node.js development patterns
    • A modular architecture designed for extension
    • A large, modern developer ecosystem
    Explore Node.js CMS

  • How does the ApostropheCMS module system work?

    Extend ApostropheCMS through modules that separate your customizations from the core platform.

    Create new content types, add business logic, customize the admin experience, and keep your project maintainable as it grows.

    Learn about modules

Improving a core widget at the project level

Add fields to a built-in widget type from your own module. Core stays untouched.

// modules/@apostrophecms/image-widget/index.js
// Same name = "improves" what was found in core. // Now every image widget will have this field ​ export default { fields: { add: { displayStyle: { type: 'select', label: 'Display Style', choices: [ { label: 'Default', value: 'default' }, { label: 'Rounded', value: 'rounded' } ] } } } }

Extending a core module to create a new content type

Create new content types by subclassing the rich feature set of our core modules.

// modules/product/index.js
// Inherits REST API, admin UI, and standard fields ​ export default { extend: '@apostrophecms/piece-type', options: { label: 'Product' }, fields: { price: { type: 'number', label: 'Price', required: true } } }

Build with the frontend framework you already use

ApostropheCMS works in both standalone and headless architectures. In standalone mode, you have two templating options built in: Nunjucks (similar to Liquid) and JSX, both server-side rendered. For sites with more complex frontend needs, Astro is the recommended pairing — it lets you bring whichever frontend framework your team already uses: Vue, React, Svelte, Solid, and others. In fully headless mode, ApostropheCMS delivers content through a REST API to whatever JavaScript frontend you're building with and still keep on-page visual editing.
  • Featured

    ApostropheCMS + Astro

    Astro is the integration that brings your frontend framework of choice — Vue, React, Svelte, Solid — to ApostropheCMS, with native in-context visual editing and no framework lock-in.

    Explore ApostropheCMS + Astro
    • Recommended

  • Nunjucks templating

    This is ApostropheCMS's traditional templating layer for projects that don't need a separate frontend build step. Support is still active for original Nunjucks-based projects.

  • Framework-agnostic headless

    Projects that need to support native apps can also consume the ApostropheCMS REST API directly, with support for rendering HTML fragments if and when needed. If the project also needs a website, that need is best served by our Astro or JSX support, which also makes a great previewing interface for editors.

How quickly can I get something real running?

The fastest way to understand ApostropheCMS is to build something. The quick start guide gets you running locally in minutes. From there, core concepts and tutorials show how ApostropheCMS is structured and how developers extend it. The goal is not just completing a tutorial — it is discovering whether ApostropheCMS fits the way your team builds.

  • Get ApostropheCMS running quickly

    Spin up a project, understand the architecture, and start building.

    Quick Start

  • Core concepts for JavaScript developers

    Learn how pages, pieces, widgets, and areas work together — and how to choose the right structure for your project.

    Core Concepts

What database and infrastructure does ApostropheCMS run on?

ApostropheCMS supports SQLite, PostgreSQL, and MongoDB. SQLite works well for local development and smaller projects. PostgreSQL is a great production choice. MongoDB has the largest document-oriented API. Regardless of what you choose, your deployment knowledge transfers — there's no proprietary runtime or hosting dependency.

  • SQLite, PostgreSQL, or MongoDB: which should I use?

    A practical guide to choosing the right database for your project size, team familiarity, and hosting environment.

    Database selection guide

  • What does a minimal production environment look like?

    Node.js, a file storage layer, and a database. This guide covers what a production-ready baseline requires.

    Deployment guide

Can I model content for a real product?

Content modeling is where many CMS projects succeed or fail. ApostropheCMS lets you define structured content in code, version control your schemas, model nested data structures, and create editorial experiences that match your application. Build structured content without giving up flexibility.

Can I customize ApostropheCMS without forking it?

Yes. ApostropheCMS is designed to be extended through modules, not by modifying core code. Create custom widgets, field types, admin UI changes, and business logic while keeping your project upgrade-friendly.

Defining a custom widget schema

Field types, structure, and what the editor UI derives from it automatically.

// modules/article-card-widget/index.js
export default { extend: '@apostrophecms/widget-type', options: { label: 'Article Card' }, fields: { add: { heading: { type: 'string', label: 'Heading', required: true }, image: { type: 'area', label: 'Image', options: { max: 1, widgets: { '@apostrophecms/image': {} } } }, _article: { type: 'relationship', label: 'Article', withType: 'article', max: 1 }, style: { type: 'select', label: 'Style', choices: [ { label: 'Standard', value: 'standard' }, { label: 'Featured', value: 'featured' } ] } } } };

How do I deliver content to a separate frontend?

ApostropheCMS provides APIs designed for modern application development. Use REST endpoints, authentication, filtering, relationships, and webhooks to deliver content wherever it needs to go. If you are using the Astro integration, many common patterns are handled for you. These tools are there when you need deeper control.

  • Query and integrate content

    Filter, sort, and connect content through ApostropheCMS APIs.

Fetching published content via the REST API

Paginated GET request with bearer token auth and search filtering, the basics of what every headless integration starts with.

javascript
// Fetch published articles, 10 per page const response = await fetch( 'https://example.net/api/v1/article?page=1&perPage=10&search=javascript', { headers: { 'Authorization': 'Bearer your-api-key' } } ); ​ const { results, pages, currentPage } = await response.json();

Does ApostropheCMS support multisite or multitenant projects?

Yes. Apostrophe Assembly gives you a multisite module for managing multiple sites from a single installation — shared codebase, separate databases per site, central dashboard, and a permission model that lets platform operators control what each site's editors can access and do. It's built for teams delivering sites to their own customers, not just managing an internal portfolio. For single-site projects, none of this is in your way. The multisite layer is additive.

Open source without lock-in

ApostropheCMS is open source because developers should have control over the software they build on.

  • MIT licensed
  • Self-hostable
  • Extensible by design
  • No proprietary runtime dependency

Inspect the code. Extend the platform. Build on your own terms.