Skip to main content

What are the key differences between WordPress and Ghost?

WordPress vs Ghost for developers: stack, data model, plugins, themes, APIs, editors, memberships, hosting, licensing and verified pricing.

Updated 19 min readMarkdown

The short version: WordPress is a PHP application with a plugin system, a flexible content model and a huge ecosystem, and Ghost is a Node.js application that does one job (publishing, memberships and newsletters) with no WordPress-style plugin system and a deliberately small data model. WordPress bends to fit almost any site, at the cost of more moving parts to secure and maintain. Ghost gives you a cleaner publishing product out of the box, at the cost of flexibility you have to build around, usually through its APIs and webhooks. If you need custom content types, a specific plugin, or multilingual content, start with WordPress. If your site is a publication with paid memberships and a newsletter, and you are comfortable with Handlebars and a Node server, Ghost is the more focused tool.

Last verified: 2026-11-13. Prices and limits below come from each vendor's own pages on that date, and they change, so check before you buy.

What are the key differences at a glance?

Here is the whole comparison on one screen, before the detail.

  • Runtime: WordPress runs on PHP with MySQL or MariaDB. Ghost runs on Node.js with MySQL 8.
  • Content model: WordPress has posts, pages, custom post types, taxonomies and post meta. Ghost has posts, pages, tags and authors, with custom fields for members only.
  • Extending it: WordPress loads plugin code into the request cycle through actions and filters. Ghost has no WordPress-style plugin system, so you extend it with theme code, code injection, API integrations and webhooks.
  • Themes: WordPress uses PHP templates (classic) or HTML templates plus theme.json (block themes). Ghost uses Handlebars templates checked by a validator called GScan.
  • APIs: WordPress ships a REST API in core, and GraphQL arrives through the WPGraphQL plugin. Ghost has a read-only Content API and a write-capable Admin API.
  • Editor: WordPress has the Gutenberg block editor. Ghost has an editor built on Lexical with "cards".
  • Memberships and newsletters: Native in Ghost. In self-hosted WordPress, plugin territory (WordPress.com bundles its own newsletter and paid-subscriber tools).
  • License: WordPress is GPLv2 or later. Ghost is MIT.
  • Market footprint: According to W3Techs on 13 November 2026, WordPress is used by 39.2% of all websites (57.9% of the sites where W3Techs can identify a CMS), and Ghost by 0.1% of all websites.

How do the runtimes and databases differ?

WordPress is PHP. Its requirements page recommends PHP 8.3 or greater, says it still works on PHP 7.4+ but flags those versions as end-of-life, recommends MySQL 8.0+ or MariaDB 10.11+, and names Apache or Nginx as the recommended servers while allowing "any server that supports PHP and MySQL". That is a big part of its reach: nearly any host can run it.

Ghost is Node.js. The Ubuntu install guide lists Ubuntu 22.04, 24.04 or 26.04, MySQL 8.0 or 8.4, Nginx, at least 1 GB of memory and a supported Node version, and the hosting guide names Node 22 or 24 LTS. MariaDB is not on the supported list, and the update guide tells MariaDB users to move to MySQL 8. That is a real constraint if your platform team standardized on MariaDB.

One operational detail is worth knowing. Ghost's hosting guide says clustering or sharding is not supported, and recommends a CDN and caching layer in front of a single instance. Plan your capacity around one well-cached instance rather than a cluster.

How do the data models differ?

This is where developers feel the gap fastest.

WordPress lets you define your own content types. A "book" or "event" or "recipe" is a custom post type with its own admin screens, its own REST route and its own template. Taxonomies group them, and post meta stores per-item fields.

add_action( 'init', function () {
	register_post_type( 'book', array(
		'label'        => 'Books',
		'public'       => true,
		'show_in_rest' => true,
		'rest_base'    => 'books',
		'supports'     => array( 'title', 'editor', 'thumbnail', 'custom-fields' ),
	) );

	register_taxonomy( 'genre', 'book', array(
		'hierarchical' => true,
		'show_in_rest' => true,
	) );

	register_post_meta( 'book', 'isbn', array(
		'type'         => 'string',
		'single'       => true,
		'show_in_rest' => true,
	) );
} );

Per the register_post_type reference, registration must not be hooked earlier than init, the post type key can't exceed 20 characters, and show_in_rest is what exposes the type to the REST API and the block editor. Because the supports array above includes custom-fields, the isbn meta shows up in the REST response too.

Ghost's model is intentionally flat. The Content API documents posts, pages, tags, authors, tiers and settings, and that is about the whole vocabulary. A post belongs to one collection (a URL grouping defined in routes.yaml), and any number of tags. Ghost does have "custom fields" now, and its pricing page lists them under the Publisher plan, but the Admin API docs describe them as member metafields in the custom namespace: extra data about your members, such as company or location. Every endpoint and example on that page is about members, and posts are never mentioned, so treat arbitrary typed fields on a post as unavailable. What people use instead is a set of workarounds: internal tags (tags prefixed with #, which the docs say are hidden from public rendering), custom per-post templates, theme custom settings, and per-post code injection.

If your content has structure beyond "an article with tags", that is the single biggest argument for WordPress, or for a headless CMS built around schemas.

Can you extend them? Plugins versus integrations

WordPress extensibility is built on hooks. The plugin handbook defines an action as something that "takes the info it receives, does something with it, and returns nothing", and a filter as something that takes a value, modifies it and returns it. Nearly everything in core can be intercepted this way.

// Filter: change a value on its way out.
add_filter( 'excerpt_length', fn() => 30 );

// Action: run code at a known point.
add_action( 'save_post_book', function ( $post_id ) {
	// invalidate a cache, ping a service, and so on
} );

That openness is why the plugin directory is so large, and also why a badly written plugin can slow your site down or open a security hole. You are the integrator.

Ghost went the other way. It has no WordPress-style plugin system, and its introduction page frames the alternative this way: "Integrations are the modern way to achieve extended functionality with ease." What you get instead: custom integrations (an API key pair scoped to your site), webhooks, code injection, and the themes layer. The one exception I found is for self-hosters: custom storage and cache adapters, which load your own module into Ghost but only decide where files and cached data live. Code injection lets you add snippets to the site header and footer, and per post or page, from the admin (Ghost's help page describes both levels). Webhooks cover an event vocabulary such as post.published, post.unpublished, page.edited, member.added, member.deleted and site.changed; the docs say a 2xx response counts as a successful delivery and anything else is a failure, and they describe no retries or timeouts, so build your receiver to be idempotent and don't assume redelivery.

The practical consequence: in Ghost, "I need a feature" often becomes "I need a small service that talks to Ghost". That is cleaner for isolation and worse for the person who just wanted to install something. Also note that on Ghost(Pro), the Starter plan does not include custom integrations, the Admin API or webhooks. Publisher and up do.

How do the themes work?

WordPress has two theme generations living side by side. Classic themes are PHP templates with the template hierarchy deciding which file renders what. Block themes, per the theme-structure handbook, need templates/index.html (that file is what makes WordPress treat the theme as a block theme) and style.css for the metadata, and typically lean on theme.json for design tokens.

{
  "$schema": "https://schemas.wp.org/trunk/theme.json",
  "version": 3,
  "settings": {
    "color": {
      "palette": [
        { "slug": "ink", "name": "Ink", "color": "#111111" }
      ]
    }
  }
}

The version: 3 in that file is the current theme.json schema version; the handbook says it works with WordPress 6.6 or later. A classic loop is the familiar one:

<?php while ( have_posts() ) : the_post(); ?>
	<h2><a href="<?php the_permalink(); ?>"><?php the_title(); ?></a></h2>
	<?php the_excerpt(); ?>
<?php endwhile; ?>

Ghost themes are Handlebars. Two templates are required, index.hbs and post.hbs; default.hbs is the base layout and must contain {{ghost_head}} and {{ghost_foot}}; package.json is required; and optional custom-*.hbs templates can be picked per post in the admin. The loop looks like this:

{{#foreach posts}}
  <h2><a href="{{url}}">{{title}}</a></h2>
  <p>{{excerpt}}</p>
{{/foreach}}

Handlebars is logic-light on purpose, so anything clever happens in helpers like {{#get}} or in your routing, not in the template. GScan runs automatically when you upload a theme in admin, and fatal errors stop the theme from activating. That gate is handy when a theme arrives from a marketplace or a contractor. Ghost also supports theme-defined custom settings, so a theme author can expose a colour or layout toggle in admin without anyone editing files.

Routing is the other half. Ghost's routes.yaml (in content/settings/) defines collections, taxonomies and channels, and can bind a template to a URL with data from the API:

routes:
  /about/team/:
    template: team
    data: page.team

That serves team.hbs at /about/team/ with the page whose slug is team. It is neat, though it is about as far as Ghost's front-end content modelling goes.

How do the APIs and headless use compare?

Both systems can be a headless backend. They just have different defaults.

WordPress exposes the REST API from core under /wp-json/wp/v2/. Reading is public for public content:

curl "https://example.com/wp-json/wp/v2/posts?per_page=5&_fields=id,slug,title"

Writing needs authentication. The handbook lists cookie authentication with a nonce for logged-in browser sessions, Application Passwords (Basic auth over HTTPS, since WordPress 5.6) for remote clients, and third-party plugins for OAuth 1.0a or JWT.

curl -X POST "https://example.com/wp-json/wp/v2/posts" \
  --user "editor:APPLICATION_PASSWORD" \
  -H "Content-Type: application/json" \
  -d '{"title":"Hello","content":"<p>Body</p>","status":"draft"}'

If you prefer GraphQL, WPGraphQL is a free, open-source plugin (GPL-3, per its site) that adds a schema over your content, with extensions for ACF fields and cache invalidation. Core doesn't ship it.

Ghost splits the surface in two. The Content API is read-only, authenticated with a key in the query string, which the docs call safe for browsers because it only reaches public data:

curl "https://your-site.example/ghost/api/content/posts/?key=CONTENT_API_KEY&include=tags,authors&limit=5" \
  -H "Accept-Version: v6.0"

Without include, tags and authors are omitted from post responses, which the docs call the most common gotcha. Browse requests return 15 records by default, and limit goes up to a documented maximum of 100 per request, so larger sets need page. The Accept-Version header sets the minimum API version.

The Admin API writes. Its key is an id:secret pair; you split on the colon, hex-decode the secret, and sign a short-lived JWT (HS256, aud of /admin/, expiry at most five minutes), sent as Authorization: Ghost <token>. The docs say to generate tokens on a server, never in the browser.

import jwt from 'jsonwebtoken';

const [id, secret] = process.env.GHOST_ADMIN_KEY.split(':');
const token = jwt.sign({}, Buffer.from(secret, 'hex'), {
  keyid: id,
  algorithm: 'HS256',
  expiresIn: '5m',
  audience: '/admin/'
});

// fetch(`${site}/ghost/api/admin/posts/`, { headers: { Authorization: `Ghost ${token}` } })

One thing that trips people: the Admin API posts docs say it expects and returns content in the Lexical format by default, and you ask for rendered HTML with ?formats=html,lexical. Programmatic publishing means producing Lexical JSON, not pasting HTML into a field.

For a headless front end, Ghost's API is small and predictable. WordPress gives you more reach (custom types, meta, plugin-contributed endpoints) and more things to configure. With either one, the front end is yours to build.

How do the editors compare?

Gutenberg stores a post as HTML in post_content, with block boundaries marked by HTML comments that carry attributes as JSON, for example <!-- wp:latest-posts {"postsToShow":4} /-->. Static blocks save markup; dynamic blocks render on the server. Everything stays in one field, and because browsers ignore the comments, older tools can still read the content. The price is complexity: block themes, patterns, the site editor and classic-theme leftovers all coexist.

Ghost's editor, Koenig, was rebuilt on React and Lexical, per the official changelog dated 25 October 2023. It is a focused writing surface with "cards" for images, embeds, signup forms, HTML and so on. Themes have to support the markup the {{content}} helper outputs, including kg-width-wide and kg-width-full classes on figures, or wide images won't break out of the column. There is far less to configure, and far less to extend: I found no documented plugin route for adding your own card.

Which one handles memberships, newsletters and paid subscriptions?

Ghost, natively. Members, tiers, free and paid signups, email newsletters and Stripe-connected subscriptions are part of the product. Ghost(Pro)'s pricing page states it takes no transaction fees on premium subscriptions (Stripe's own fees still apply). Self-hosting adds one real requirement: the newsletter docs say bulk email can't go through plain SMTP, and Mailgun is currently the only supported bulk provider, configured with API keys in settings.

WordPress core has users and roles, and not much more. Paid access, drip content and email lists come from plugins (WooCommerce with a subscriptions extension, MemberPress, Paid Memberships Pro, and a long list of newsletter plugins) and from third-party email services. That is more choice and more glue. WordPress.com differs here: its pricing page lists a built-in newsletter on every plan and paid subscribers on every plan including Free, with a platform fee on paid subscriptions that falls from 10% on Free to 0% on Commerce (Stripe's processing fee is separate), plus PayPal and Stripe payment buttons on Premium and above.

What about multisite and multiple languages?

WordPress has Multisite built in: several sites on one installation, each with its own content tables and a shared user table, path-based or domain-based, and it needs rewrites enabled. For agencies or networks of sites, this is a real advantage.

Ghost has no multisite feature that I found in its docs. Its i18n story is the {{t}} helper: you set a publication language in admin, wrap theme strings in {{t}} and add one JSON file per language under locales/, which localizes your theme's interface text. Ghost also translates its own system text (transactional emails, Portal, search and comments). For multi-language content, Ghost's translation FAQ recommends one Ghost install per language when each language gets different content, and a translation service such as Weglot or Transifex when the same content appears in several languages. There is no built-in per-post translation workflow, so a bilingual Ghost site is something you assemble yourself. WordPress core doesn't translate your content either, but the multilingual plugin ecosystem (WPML, Polylang and others) is mature.

What does hosting and maintenance involve?

Ghost self-hosting is tooling-led. ghost-cli installs and configures it, ghost backup and ghost update handle upgrades, and Ghost releases weekly (the update docs say 6.x is the current major version at the time of writing). A Docker option exists, but the install docs still label it a preview, with Caddy and MySQL in the Compose stack. One wrinkle: the update docs say web analytics isn't compatible with Ghost-CLI installs and point to that Docker preview.

WordPress self-hosting is less prescriptive and, if you use a decent managed host, nearly invisible. Core applies minor and security updates automatically by default. Major core updates are off by default for installs that predate 5.6 and on for newer fresh installs, and plugin and theme updates are not automatic except in special cases. WP-CLI covers scripting. The cost is the patch surface: more plugins, more things to keep current.

Both have a managed option, which brings us to money.

How much do the managed options cost?

Ghost(Pro) prices, as shown on ghost.org/pricing on 2026-11-13, in USD per month. The page has a yearly/monthly toggle and a member slider that starts at 1,000, and the figures below are at that starting position. Yearly billing is the cheaper rate in every case, so each line gives both:

  • Starter: $15 per month billed yearly, $18 billed monthly. Up to 1,000 members, one staff user, newsletter, no marketplace or custom themes, and a free .link domain registration for the first year.
  • Publisher: $29 per month billed yearly, $35 billed monthly, at 1,000 members. Three staff users, custom and marketplace themes, paid subscriptions, tips, custom fields, Admin API, webhooks and custom integrations, up to 3 premium tiers. The price rises with the slider: at 10,000 members the page shows $88 yearly-billed or $105 monthly-billed.
  • Business: $199 per month billed yearly, $239 billed monthly, covering up to 10,000 members at that one flat price. Above 10,000 it rises (at 25,000 members the page shows $266 yearly-billed or $319 monthly-billed). 15 staff users, priority support, higher usage limits, up to 10 premium tiers. Custom SSL and a subdirectory install are $50 per month add-ons.
  • Custom: contact sales. Unlimited staff and members, dedicated IP, 99.9% uptime SLA.

Starter is capped at 1,000 members, and the page says you will be notified to upgrade as your member count grows.

WordPress.com prices, from wordpress.com/pricing on 2026-11-13, in USD per month ex-tax, yearly billing first and monthly billing second:

  • Free: $0, with WordPress.com ads shown to visitors.
  • Personal: $4 billed yearly ($9 month-to-month), 6 GB.
  • Premium: $8 billed yearly ($18 monthly), 13 GB.
  • Business: $25 billed yearly ($40 monthly), 50 GB, adding site-assistant and staging features.
  • Commerce: $45 billed yearly ($70 monthly), 50 GB, with WooCommerce-focused ecommerce tooling.
  • Enterprise (WordPress VIP): no price listed.

The page also lists discounts for two- and three-year terms, and it says every plan above Free can install plugins (more than 60,000 on the WordPress.com marketplace, or an uploaded plugin). WordPress.com's SSH support page says SSH and WP-CLI access are available on plugin-enabled sites on Personal, Premium, Business and Commerce.

Which license is which?

WordPress is released under GPLv2 or later, and the license page says plugins and themes are derivative work that inherit the GPL, which is why the plugin ecosystem is overwhelmingly GPL. Ghost is MIT licensed (the repository says so), with the "Ghost" name and logo as trademarks of Ghost Foundation Ltd. The README also says 100% of revenue goes to the Ghost Foundation. For a fork or commercial redistribution MIT is simpler; a WordPress plugin business plans around the GPL.

What other options exist if neither fits?

Four that come up often, none a universal answer.

  • Headless CMS (Strapi, Payload): You model your own schema and build the front end. Strapi's Community edition is listed as free and open source under MIT, self-hosted, and Payload describes itself as an open-source, Next.js-based fullstack framework that you add to a new or existing Next.js app. Pick these when the content model is the hard part. Expect to write and host your own front end, and to assemble memberships and email yourself.
  • Static generators (Hugo, Astro): Markdown in Git, built to HTML, hosted anywhere. Cheap to host because the output is static files, with no admin UI for non-developers unless you bolt one on.
  • Newsletter-first platforms (Substack, Beehiiv): If the product is the newsletter, these skip the CMS question entirely. You trade away theme control and data-model flexibility.
  • VeloCMS: a hosted blog CMS at velocms.org, built on Next.js and PocketBase, with membership and newsletter tools built in. It is newer, with a plugin library in the dozens rather than WordPress's tens of thousands and a much smaller community, and it is sold as a hosted service with no self-hosted edition. A good fit for a team that wants a blog, memberships and email in one hosted product and doesn't need WordPress-scale plugin depth. A poor fit if you need a specific WordPress plugin or must self-host.

So which should you pick?

  • WordPress: custom content types, plugin availability, multisite, multilingual sites, or a team that already knows PHP.
  • Ghost: a publication with paid members and a newsletter, a JavaScript team, and a willingness to build around a small data model.
  • Headless CMS or static generator: a developer-owned site where the content schema or the front end is the product.
  • Newsletter platform: the newsletter is the business.
  • VeloCMS: a hosted blog with memberships and email, if you can live without WordPress-scale plugin depth.

FAQ

Does Ghost have plugins? Not in the WordPress sense. Ghost extends through custom integrations, webhooks, code injection and themes, and its own docs say integrations are the way to extend it rather than plugins. Self-hosters can also write custom storage or cache adapters.

Can Ghost do custom post types? Not in the WordPress sense. Ghost's custom fields, per its Admin API docs, belong to members, and the docs describe no way to define new post types or add typed fields to posts.

Can I migrate from WordPress to Ghost? Ghost publishes an official WordPress migration guide, and the same docs list guides for Medium, Substack and others. Content moves; plugin behaviour (forms, SEO plugins, custom post types) doesn't, so inventory what your site relies on first.

Is WordPress.com the same as WordPress? No. WordPress.com is Automattic's hosted service with its own plans. WordPress.org is where you download the free GPL software to host yourself.

Sources

All accessed 2026-11-13.

About the author

  • Building VeloCMS.org , A fast multilingual CMS for blogs and online stores. I write about headless CMS, Next.js, SEO and moving off WordPress and Shopify.

If you want to compare options, WordPress offers more customization while Ghost keeps publishing simpler and cleaner. For a visual starting point, you could try Marginalia, a free personal blog template with source code and editable photo-led sections. Live demo: https://alpha.webuilder.me/gallery/primitive/marginalia-blog?utm_source=hashnode&utm_medium=comment&utm_campaign=template-promo&utm_content=marginalia-blog