Glueful

Build production PHP APIs
without starting from zero

Start with glueful/api-skeleton, then grow into a full API platform with explicit routing, context-aware DI, authentication flows, queues, notifications, storage, OpenAPI generation, and operational CLI tooling.

API Skeleton First
Explicit Routes + DI
Built For Real Deployments

Start With The Skeleton

GitHub

Browse Extensions

Terminal
composer create-project glueful/api-skeleton my-project
cd my-project
php glueful install --quiet
php glueful scaffold:controller UserController --api
php glueful generate:openapi --ui
php glueful serve

A faster path from idea to deployed API

Glueful is opinionated where it helps: start from a working API app, use explicit routes and controllers, rely on context-aware DI instead of hidden globals, and add higher-level features only when your app needs them.
PHP 8.3+
ApplicationContext + DI
OpenAPI + CLI Tooling
UserController.php
PHP 8.2+
class UserController extends BaseController
{
    public function __construct(
        private UserService $userService
    ) {}

    
    public function create(Request $request): Response
    {
        $user = $this->userService->createUser($request->validated());

        return Response::created($user);
    }
}
Type Safety
Auto DI
Attributes

Why developers adopt Glueful

Glueful is strongest when you want a pragmatic API framework that starts lean but already includes the hard parts teams usually stitch together later.

Fast Onboarding
Explicit Architecture
Built-In API Ops

    Start From A Working API App

    `glueful/api-skeleton` gives you bootstrap, config, starter routes, migrations, SQLite by default, queue configuration, OpenAPI configuration, extension loading, and a real CLI entrypoint on day one.

    Stay Explicit As You Scale

    Glueful’s `ApplicationContext`, explicit routing, and container-driven services make the architecture easier to reason about than magic-heavy frameworks that hide request state and service resolution.

    Ship More Than CRUD

    Auth flows, notifications, queues, rate limiting, distributed locks, file uploads, OpenAPI generation, and production checks are already part of the framework story, not an afterthought.

    Add Official Extensions

    Extend the core with official packages for RBAC, social login, email delivery, push notifications, full-text search, payments, and runtime integrations without turning the framework itself into a monolith.

What developers get immediately

Glueful’s starter path is valuable because it shortens the gap between “new project” and “working API with operational basics.”

    Scaffolding

    Generate controllers, models, requests, jobs, rules, tests, factories, seeders, filters, and middleware with the `scaffold:*` commands instead of hand-rolling boilerplate.

    API Documentation

    Use `php glueful generate:openapi --ui` to generate your API spec and a browsable UI without wiring a separate documentation stack together.

    Operational Defaults

    Health checks, security scanning, route diagnostics, queue presets, storage configuration, and deployment-oriented config are present from the start.

    API Ergonomics

    Versioning, field selection, rate limiting, eventing, notifications, and extension hooks make Glueful fit real API teams better than a bare router-and-container setup.

From starter app to production API platform

Start with routes and controllers in the skeleton. Then add database-backed resources, auth and sessions, queues and notifications, storage, extensions, and generated OpenAPI docs as the application grows.

    Good Fit For

    Internal APIs, SaaS backends, webhook-heavy services, queue-driven workloads, and teams that want explicit PHP architecture without rebuilding the same API infrastructure on every project.

    Extension Ecosystem

    Start with the lean framework, then add Aegis, Entrada, Payvia, Meilisearch, Notiva, email-notification, and other Glueful extensions as your product needs grow.

    Next Step

    Start with the install path, build your first endpoint, then move into routing, validation, auth, queues, and deployment with the docs path that matches the framework’s current API surface.