[opensourcedex]

pagible is a free, open source content management systems (cms) project written in PHP and released under MIT. It has 587 GitHub stars, 14 forks and 9 open issues, and was last pushed 11 hours ago. On this registry it ranks #43 of 47 tracked projects in Content Management Systems (CMS), with 5 head-to-head comparisons available. It gained 1 stars over the last 3 tracked days.

What is pagible?

PagibleAI CMS is an MIT-licensed, API-first content management package for Laravel that installs into an existing PHP application and is aimed at Laravel teams that want WordPress-like editing, Contentful-style structured content, AI assistance, and multi-tenant scale.

What it is

PagibleAI CMS is a cloud-native Laravel CMS package distributed as a modular monorepo. It is an API-first content management system that can be installed into any existing Laravel application, with sub-packages for Core data models, Admin, GraphQL, JSON:API, AI, Search, MCP, Backup, Import, Cashier, Theme, and Themes. The stack is PHP 8.2+, Laravel 11.x, 12.x, and 13.x, a Vue.js 3 and Vuetify admin panel, Lighthouse for GraphQL, Prism and Prisma PHP for AI and LLM integration, and Vite for frontend builds.

The concrete problem is that a Laravel team needing structured content usually has to run a separate WordPress instance or integrate an external headless CMS such as Contentful. PagibleAI CMS replaces that split setup by combining WordPress-like ease of use with Contentful-style structured content management inside the Laravel application itself, and it includes an importer for WordPress content. It scales from a single SQLite-backed page to millions of pages with database clusters, and it supports multi-domain routing and multi-tenancy.

Key capabilities

  • Structured content management with a hierarchical page tree stored as a nested set using _lft and _rgt columns, plus drag-and-drop page management in the admin panel.
  • Two APIs: a read-only JSON:API for frontend content delivery and a GraphQL admin API built on Lighthouse.
  • AI-powered content generation, image manipulation, and translation through Prism and Prisma PHP.
  • An MCP API that exposes more than 30 tools for LLM-driven content management.
  • Multi-language support, multi-domain routing, and multi-tenancy, with per-tenant backup and restore that includes media files and integrity verification.
  • Full-text search through a custom Laravel Scout engine supporting FTS5 on SQLite, MATCH/AGAINST on MySQL, tsvector on PostgreSQL, and CONTAINSTABLE on SQL Server.
  • Paid page access through Cashier, selling subscriptions or one-time payments via Stripe, Paddle, or Mollie, alongside importers for WordPress and other external CMS platforms.

Who uses it and how

  • Laravel product teams that need to add CMS features to an existing application rather than run a separate CMS, since PagibleAI installs into the Laravel app and uses the same deployment.
  • Multi-tenant and multi-domain operators, because the package supports multi-tenancy and multi-domain routing and scales from a single SQLite-backed page to millions of pages with database clusters.
  • Editorial teams that need structured workflows: content is versioned as immutable snapshots, editors see the latest draft while the public sees the published version, and a full audit trail records changes.
  • Publishers selling access to restricted pages, using Cashier with Stripe, Paddle, or Mollie for subscriptions and one-time payments.
  • Teams migrating from WordPress, using the included importer and the ability to assign shared content to multiple pages.

Getting started

PagibleAI CMS is installed as a package into an existing Laravel application, and the README's Getting Started section is the entry point for setup. The runtime requirements named in the facts are PHP 8.2+ with Laravel 11.x, 12.x, or 13.x.

How it compares

The facts position PagibleAI CMS between WordPress and Contentful: it claims WordPress-like ease of use while providing Contentful-style structured content management, and it ships an importer for WordPress content. Unlike a hosted headless CMS account, it is an MIT-licensed package installed into a Laravel application, so the CMS data and delivery APIs live inside infrastructure the team already operates.

When to use it — and when not to

Self-hosting PagibleAI CMS means operating a Laravel application, one of the supported databases (SQLite, MySQL, PostgreSQL, or SQL Server), LLM provider credentials for the AI features, and payment provider accounts if paid page access is used. Teams that are not on Laravel or PHP should not pick it, because the package is designed to be installed into an existing Laravel application rather than run as a standalone CMS. The main weakness visible in the facts is the project's small footprint: 587 stars, 14 forks, and 9 open issues, and the README excerpt provided here is largely a feature and architecture overview that does not contain the Getting Started steps.

project readme (upstream, from github) — read inline

PagibleAI CMS - Simple as Wordpress, the power of Contentful!

The easy, flexible and scalable API-first PagibleAI CMS package for Laravel.

Table of Contents

About

PagibleAI CMS is an API-first content management system that can be installed into any existing Laravel application. It combines the ease of use of WordPress with the structured content management capabilities of Contentful, powered by AI for content generation, image manipulation, and translation.

Whether you need a simple blog or a multi-tenant, multi-domain CMS serving millions of pages, PagibleAI scales to your needs — from a single SQLite-backed page to database clusters.

Features

  • Structured Content - Manage structured content like in Contentful
  • AI-Powered - AI generates/enhances drafts and images
  • Hierarchical Pages - Hierarchical page tree with drag & drop
  • Shared Content - Assign shared content to multiple pages
  • Versioning - Save, publish, schedule and revert drafts
  • Audit Trail - Full version history and audit trail
  • Extensible Elements - Define new content elements in seconds
  • JSON API - Extremely fast JSON frontend API
  • GraphQL API - Versatile GraphQL admin API
  • Multi-language - Multi-language support
  • Multi-domain - Multi-domain routing
  • Multi-tenancy - Multi-tenancy capable
  • Importers - Importer for WordPress, etc.
  • MCP API - 30+ tools for LLM-driven content management
  • Full-text Search - Across SQLite, MySQL, PostgreSQL and SQL Server
  • Paid Page Access - Sell subscriptions and one-time access through Stripe, Paddle, or Mollie
  • Scalable - From single page with SQLite to millions of pages with DB clusters
  • Open Source - Fully open source

Tech Stack

Technology Purpose
PHP 8.2+ Backend language
Laravel 11.x / 12.x / 13.x Web framework
Vue.js 3 Admin panel frontend
Vuetify Admin UI component library
Lighthouse GraphQL API
Prism / Prisma PHP AI/LLM integration
Vite Frontend build tool

Architecture

PagibleAI CMS is a modular monorepo split into focused sub-packages. Each package handles a specific concern and can be used independently:

  • Core provides the data models (Page, Element, File, Version), multi-tenancy, permissions, and migrations
  • Admin delivers the Vue.js-based admin panel with drag & drop page management
  • GraphQL exposes the admin API via Lighthouse for content editing
  • JSON:API provides a read-only frontend API for content delivery
  • AI integrates LLM providers through Prism/Prisma PHP for content generation, image manipulation, and translation
  • Search implements a custom Laravel Scout engine supporting FTS5 (SQLite), MATCH/AGAINST (MySQL), tsvector (PostgreSQL), and CONTAINSTABLE (SQL Server)
  • MCP offers 30+ tools for LLM-driven content management
  • Backup provides per-tenant backup and restore with media files, integrity verification, and cross-tenant support
  • Import provides importers from external CMS platforms (WordPress, etc.)
  • Cashier sells frontend page access through subscriptions or one-time payments using Stripe, Paddle, or Mollie
  • Theme handles frontend rendering with Blade templates
  • Themes contains high-quality frontend themes

Pages are organized as a nested set tree (using _lft/_rgt columns). All content changes are tracked as immutable version snapshots — editors see the latest draft while the public sees the published version. Caching is per-page with configurable duration.

Project Structure

pagible/
├── src/          Meta-package (install orchestrator + serve command)
├── core/         Models, permissions, tenancy, utilities, migrations
├── admin/        Vue.js admin panel (Vuetify + Vite)
├── ai/           AI features (Prism / Prisma PHP)
├── graphql/      GraphQL API (Lighthouse)
├── backup/       Backup and restore
├── cashier/      Shared payment-backed frontend access
├── cashier-*/    Stripe, Paddle, and Mollie Cashier adapters
├── import/       CMS importers (WordPress, etc.)
├── search/       Full-text search (Laravel Scout)
├── jsonapi/      Read-only JSON:API
├── mcp/          MCP server (30+ tools)
├── theme/        Frontend rendering (Blade templates)
├── themes/       Frontend themes (CSS)
├── tests/        Shared test infrastructure
├── config/       Configuration files
└── phpunit.xml   Aggregated test runner

Getting Started

Prerequisites

  • PHP 8.2 or higher
  • Composer
  • Node.js & npm (for admin panel development)
  • A working Laravel 11.x, 12.x, or 13.x installation

Installation

If you don't have an existing Laravel application, create one first:

composer create-project laravel/laravel pagible
cd pagible

Then install PagibleAI CMS:

composer req aimeos/pagible
php artisan cms:install
php artisan migrate

Fresh Laravel applications contain a static public/robots.txt file. Web servers serve that file before Laravel receives the request. If it contains custom rules, first copy them into the robots.txt configuration element on the root page and publish the change. Then remove the static file to enable Pagible's dynamic route:

rm public/robots.txt

The dynamic route serves the published rules together with the generated sitemap and news sitemap URLs. Alternatively, configure the web server to pass /robots.txt to Laravel even when the static file exists.

Now, adapt the .env file of your application and change the APP_URL setting to your domain. If you are using php artisan serve for testing, add the port of the internal web server (APP_URL=http://localhost:8000). Otherwise, the uploading files will fail because they wouldn't be loaded!

Add a line in the "post-update-cmd" section of your composer.json file to update the admin backend files after each update:

"post-update-cmd": [
    "@php artisan vendor:publish --force --tag=cms-admin --tag=cms-graphql",
    "@php artisan vendor:publish --tag=cms-theme",
    "@php artisan migrate",
    ...
],

Authorization

To allow users to edit CMS content or to create a new users if they don't exist yet, you can use the cms:user command (replace the e-mail address by the users one):

php artisan cms:user -e [email protected]

This adds admin privileges for the specified user. For more information regarding authorization and permissions, please have a look into the authorization and permission page.

The CMS admin backend is available at (replace "mydomain.tld" with your own one):

http://mydomain.tld/cmsadmin

Selling access to restricted pages

Install exactly one Pagible Cashier provider in the Laravel application that already contains Pagible CMS:

composer require aimeos/pagible-cashier-stripe
# or: aimeos/pagible-cashier-paddle
# or: aimeos/pagible-cashier-mollie

php artisan cms:install:cashier

For Stripe, an interactive installer offers to create the webhook when APP_URL, STRIPE_KEY, and STRIPE_SECRET are ready. Automated installations must opt in with --webhook.

Add Pagible's CashierAccess trait and the selected provider's Billable trait to the application user model. Then configure the provider credentials and verified webhooks, define a frontend access value such as premium-members, and run the local readiness check:

php artisan cms:cashier:check

Use that same access value in both places in the CMS admin:

  1. Add a pricing element to a public sales page and select premium-members as the package's frontend access role. Add a subscription price, a one-time price, or both, then publish the pricing content.
  2. Open the page being sold, choose Access, select Restricted, add premium-members, and apply the change.

Verified payment webhooks grant and revoke the role automatically. A successful one-time payment grants permanent access unless it is fully refunded or charged back. A subscription grants access through its provider-confirmed paid period. See the Pagible Cashier guide for the user-model example, access-catalog setup, provider-specific price fields, webhook configuration, private files, cancellations, and an end-to-end checklist.

Configuration

File uploads use the Laravel dis

readme truncated — read the full docs on github

Frequently asked questions

Is pagible free to use?

pagible is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does pagible do?

Easy, flexible and powerful cloud-native Laravel CMS package powered by AI with JSON:API, GraphQL API, templates, and themes

What is pagible written in?

pagible is primarily written in PHP. Its source is publicly available at https://github.com/aimeos/pagible, and it has 587 GitHub stars.