PHPackages                             devravik/laravel-licensing - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Authentication & Authorization](/categories/authentication)
4. /
5. devravik/laravel-licensing

ActiveLibrary[Authentication & Authorization](/categories/authentication)

devravik/laravel-licensing
==========================

A production-ready Laravel package for generating, managing, activating, and validating software licenses.

1.1.0(2mo ago)943MITPHPPHP ^8.1CI passing

Since Feb 27Pushed 2mo agoCompare

[ Source](https://github.com/devravik/laravel-licensing)[ Packagist](https://packagist.org/packages/devravik/laravel-licensing)[ Docs](https://github.com/devravik/laravel-licensing)[ RSS](/packages/devravik-laravel-licensing/feed)WikiDiscussions main Synced 1mo ago

READMEChangelog (2)Dependencies (11)Versions (3)Used By (0)

[![License Manager Banner](License_Manager_Banner_88271288.jpg)](License_Manager_Banner_88271288.jpg)

Laravel Licensing
=================

[](#laravel-licensing)

[![Latest Version on Packagist](https://camo.githubusercontent.com/5ae1ada3531a8df324700b14517446068c333ea53aac7b712dcfffa8ca9230e1/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f646576726176696b2f6c61726176656c2d6c6963656e73696e672e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/devravik/laravel-licensing)[![Total Downloads](https://camo.githubusercontent.com/9b9b87e2268765284e7d22f3ff64bec5d2d4f07d775ce8207ca071e3b2a280ff/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f64742f646576726176696b2f6c61726176656c2d6c6963656e73696e672e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/devravik/laravel-licensing)[![Tests](https://camo.githubusercontent.com/dac5398b22e6117d035cd227d6e16751c86a4e4cd217c80a07513860f54b59b5/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f616374696f6e732f776f726b666c6f772f7374617475732f646576726176696b2f6c61726176656c2d6c6963656e73696e672f74657374732e796d6c3f6272616e63683d6d61696e266c6162656c3d7465737473267374796c653d666c61742d737175617265)](https://github.com/devravik/laravel-licensing/actions/workflows/tests.yml)[![PHP Version](https://camo.githubusercontent.com/4d22cf784a8f5957f8bd05587d9816c052dad55e86e788d1937156226e399d38/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f7068702d762f646576726176696b2f6c61726176656c2d6c6963656e73696e672e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/devravik/laravel-licensing)[![License](https://camo.githubusercontent.com/789ea5bb0f2a2f13f10338e17718d5fedb3a66873e41f2559b70ebba6e7a0144/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f6c2f646576726176696b2f6c61726176656c2d6c6963656e73696e672e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/devravik/laravel-licensing)

A production-ready Laravel package for generating, managing, activating, and validating software licenses directly inside your application.

License keys are hashed before storage (never plaintext in the database), activations are seat-controlled, and the entire lifecycle creation, validation, activation, revocation, and expiry is covered by typed exceptions and dispatchable events.

---

Starter Kit
-----------

[](#starter-kit)

**New to this package?** Check out the [Laravel Licensing Starter](https://github.com/devravik/laravel-licensing-starter) a complete working example that demonstrates how to use this package in a real Laravel application.

The starter kit includes:

- Full license management dashboard
- User management with license assignment
- License creation, activation, and validation workflows
- API endpoints for license validation and activation
- Complete UI built with Laravel Breeze
- Demo data and examples

Perfect for understanding how to integrate this package into your own application!

---

Requirements
------------

[](#requirements)

DependencyVersionPHP`^8.1` (PHP 8.2+ required for Laravel 11 / 12)Laravel`^10.0 | ^11.0 | ^12.0`---

Installation
------------

[](#installation)

**1. Install via Composer**

```
composer require devravik/laravel-licensing
```

**2. Publish the config**

```
php artisan vendor:publish --tag=license-config
```

**3. Publish the migrations**

```
php artisan vendor:publish --tag=license-migrations
```

**4. Run the migrations**

```
php artisan migrate
```

The package auto-registers its service provider via Laravel's package discovery. No manual registration is required.

---

Configuration
-------------

[](#configuration)

After publishing, the config file lives at `config/license.php`:

```
return [
    'license_model'        => \DevRavik\LaravelLicensing\Models\License::class,
    'activation_model'     => \DevRavik\LaravelLicensing\Models\Activation::class,
    'key_length'           => env('LICENSE_KEY_LENGTH', 32),
    'hash_keys'            => env('LICENSE_HASH_KEYS', true),
    'default_expiry_days'  => env('LICENSE_DEFAULT_EXPIRY_DAYS', 365),
    'grace_period_days'    => env('LICENSE_GRACE_PERIOD_DAYS', 7),
    'license_generation'   => env('LICENSE_GENERATION', 'random'), // 'random' | 'signed'
    'signature'            => [
        'public_key'  => env('LICENSE_PUBLIC_KEY'),
        'private_key' => env('LICENSE_PRIVATE_KEY'),
    ],
];
```

OptionTypeDefaultDescription`license_model``string``License::class`Eloquent model for licenses`activation_model``string``Activation::class`Eloquent model for activations`key_length``int``32`Length of generated license keys (chars)`hash_keys``bool``true`Hash keys with bcrypt before storage`default_expiry_days``int|null``365`Default license duration; `null` = no expiry`grace_period_days``int``7`Days of temporary validity after expiry; `0` = disabled`license_generation``string``'random'`Generation strategy: `'random'` or `'signed'``signature.public_key``string|null``null`Ed25519 public key (file path or base64 string)`signature.private_key``string|null``null`Ed25519 private key (file path or base64 string)**Environment variables:**

```
LICENSE_KEY_LENGTH=32
LICENSE_HASH_KEYS=true
LICENSE_DEFAULT_EXPIRY_DAYS=365
LICENSE_GRACE_PERIOD_DAYS=7
LICENSE_GENERATION=random
LICENSE_PUBLIC_KEY=
LICENSE_PRIVATE_KEY=
```

---

Usage
-----

[](#usage)

### Creating a License

[](#creating-a-license)

Use the `HasLicenses` trait on any Eloquent model that should own licenses, then build with the fluent API:

```
// app/Models/User.php
use DevRavik\LaravelLicensing\Support\HasLicenses;

class User extends Authenticatable
{
    use HasLicenses;
}
```

```
use DevRavik\LaravelLicensing\Facades\License;

$license = License::for($user)
    ->product('pro')
    ->seats(3)
    ->expiresInDays(365)
    ->create();

// The raw key is only available at creation time. Store or display it immediately.
$rawKey = $license->key;
```

**Builder reference:**

MethodDescriptionRequired`for(Model $owner)`Bind the license to an Eloquent modelYes`product(string $product)`Set the product name or tierYes`seats(int $count)`Maximum activations allowed (default: 1)No`expiresInDays(int $days)`Expiry relative to nowNo`expiresAt(Carbon $date)`Explicit expiry dateNo`create()`Persist and return the licenseYes> If neither `expiresInDays()` nor `expiresAt()` is called, the value from `config('license.default_expiry_days')` is used.

---

### Validating a License

[](#validating-a-license)

```
use DevRavik\LaravelLicensing\Facades\License;
use DevRavik\LaravelLicensing\Exceptions\InvalidLicenseException;
use DevRavik\LaravelLicensing\Exceptions\LicenseExpiredException;
use DevRavik\LaravelLicensing\Exceptions\LicenseRevokedException;

try {
    $license = License::validate($rawKey);
    // Valid. Check grace period if needed:
    if ($license->isInGracePeriod()) {
        // Warn: expires in $license->graceDaysRemaining() days
    }
} catch (LicenseExpiredException $e) {
    // Expired beyond grace period
} catch (LicenseRevokedException $e) {
    // Revoked
} catch (InvalidLicenseException $e) {
    // Key not found
}
```

---

### Activating a License

[](#activating-a-license)

Bind a license to a domain, IP address, machine ID, or any identifier. Each binding consumes one seat.

```
use DevRavik\LaravelLicensing\Facades\License;
use DevRavik\LaravelLicensing\Exceptions\SeatLimitExceededException;

try {
    $activation = License::activate($rawKey, 'app.example.com');
} catch (SeatLimitExceededException $e) {
    // All seats occupied
}
```

---

### Deactivating a License

[](#deactivating-a-license)

Remove an activation to free up a seat:

```
License::deactivate($rawKey, 'app.example.com');
```

---

### Revoking a License

[](#revoking-a-license)

Immediately and permanently invalidate a license:

```
License::revoke($rawKey);
```

---

### Checking License Status

[](#checking-license-status)

```
$license = License::find($rawKey); // no exception on failure  returns null

$license->isValid();           // not revoked and not fully expired
$license->isExpired();         // past expiration date
$license->isInGracePeriod();   // expired but within grace window
$license->isRevoked();         // revoked_at is set
$license->seatsRemaining();    // available activation slots
$license->graceDaysRemaining(); // days left in grace period
$license->activations;         // Eloquent collection of current activations
```

---

Facade Reference
----------------

[](#facade-reference)

MethodSignatureReturnsDescription`for``for(Model $owner)``LicenseBuilder`Begin building a license`validate``validate(string $key)``License`Validate and return license; throws on failure`activate``activate(string $key, string $binding)``Activation`Activate a license against a binding`deactivate``deactivate(string $key, string $binding)``bool`Remove an activation binding`revoke``revoke(string $key)``bool`Permanently revoke a license`find``find(string $key)``License|null`Find a license without validation---

Artisan Commands
----------------

[](#artisan-commands)

The package provides comprehensive Artisan commands for managing licenses:

### Generate License Keys

[](#generate-license-keys)

Generate Ed25519 key pairs for signed license verification:

```
php artisan licensing:keys
```

**Options:**

- `--force` - Overwrite existing keys if they already exist
- `--show` - Display the generated keys in the console
- `--write` - Automatically append keys to your `.env` file

### License Status

[](#license-status)

Check package configuration and status:

```
php artisan license:status
```

### List Licenses

[](#list-licenses)

List all licenses with optional filtering:

```
php artisan licensing:list
php artisan licensing:list --product=pro
php artisan licensing:list --status=active
php artisan licensing:list --expired
php artisan licensing:list --revoked
```

**Options:**

- `--product` - Filter by product name
- `--owner-type` - Filter by owner model class
- `--owner-id` - Filter by owner ID
- `--status` - Filter by status (active|expired|revoked)
- `--expired` - Show only expired licenses
- `--revoked` - Show only revoked licenses
- `--per-page` - Number of licenses per page (default: 15)

### Show License

[](#show-license)

Display detailed information about a specific license:

```
php artisan licensing:show --key=abc123...
php artisan licensing:show --id=1
php artisan licensing:show --id=1 --full
```

**Options:**

- `--key` - License key
- `--id` - License ID
- `--full` - Show full license key (unmasked)

### Create License

[](#create-license)

Create a new license interactively or via options:

```
# Interactive mode
php artisan licensing:create

# Non-interactive mode
php artisan licensing:create \
    --owner-type=App\\Models\\User \
    --owner-id=1 \
    --product=pro \
    --seats=5 \
    --expires-days=365 \
    --non-interactive
```

**Options:**

- `--owner-type` - Owner model class (e.g., `App\\Models\\User`)
- `--owner-id` - Owner model ID
- `--product` - Product name or tier
- `--seats` - Number of seats (default: 1)
- `--expires-days` - Days until expiration (leave empty for never)
- `--non-interactive` - Skip interactive prompts

### Revoke License

[](#revoke-license)

Revoke a license by key or ID:

```
php artisan licensing:revoke --key=abc123...
php artisan licensing:revoke --id=1 --force
```

**Options:**

- `--key` - License key
- `--id` - License ID
- `--force` - Skip confirmation prompt

### Activate License

[](#activate-license)

Activate a license for a binding:

```
php artisan licensing:activate --key=abc123... --binding=domain.com
php artisan licensing:activate --id=1 --binding=192.168.1.1
```

**Options:**

- `--key` - License key
- `--id` - License ID
- `--binding` - Activation binding (domain, IP, machine ID, etc.)

### Deactivate License

[](#deactivate-license)

Remove an activation binding:

```
php artisan licensing:deactivate --key=abc123... --binding=domain.com
php artisan licensing:deactivate --id=1 --binding=192.168.1.1
```

**Options:**

- `--key` - License key
- `--id` - License ID
- `--binding` - Binding to remove (if omitted, shows list to choose from)

### License Statistics

[](#license-statistics)

Display license and activation statistics:

```
php artisan licensing:stats
php artisan licensing:stats --product=pro
```

**Options:**

- `--product` - Filter statistics by product

**Output includes:**

- Total, active, expired, and revoked license counts
- Total, used, and available seat counts
- Total activation count
- Seat usage percentage

---

Middleware
----------

[](#middleware)

The package ships two middleware aliases that are registered automatically.

### Protect routes requiring a specific product

[](#protect-routes-requiring-a-specific-product)

```
// routes/api.php
Route::middleware('license:pro')->group(function () {
    Route::get('/pro/dashboard', [ProDashboardController::class, 'index']);
});

Route::middleware('license:enterprise')->group(function () {
    Route::get('/enterprise/analytics', [AnalyticsController::class, 'index']);
});
```

### Protect routes requiring any valid license

[](#protect-routes-requiring-any-valid-license)

```
Route::middleware('license.valid')->group(function () {
    Route::get('/app', [AppController::class, 'index']);
});
```

The middleware reads the license key from the `X-License-Key` request header (or `license_key` query/body parameter).

### Middleware Responses

[](#middleware-responses)

Failure ReasonHTTP StatusNo key provided`401 Unauthorized`Key not found`404 Not Found`Revoked or expired`403 Forbidden`Wrong product tier`403 Forbidden`Seat limit exceeded`422 Unprocessable Entity`For `Accept: application/json` requests the middleware returns:

```
{
    "error": "license_check_failed",
    "message": "The provided license key is invalid."
}
```

For web requests, `abort()` is called with the appropriate status code.

You can customise the response by extending `AbstractLicenseMiddleware` and overriding `denyResponse()`.

---

Events
------

[](#events)

EventFired WhenProperties`LicenseCreated``create()` is called`$event->license``LicenseActivated``activate()` is called`$event->license`, `$event->activation``LicenseDeactivated``deactivate()` is called`$event->license`, `$event->binding``LicenseRevoked``revoke()` is called`$event->license``LicenseExpired`Dispatched manually from a scheduled command`$event->license``LicenseExpired` is intentionally **not** dispatched automatically it should be fired from a scheduled command so you control when and how expiration is processed:

```
// routes/console.php  (Laravel 11+)
use Illuminate\Support\Facades\Schedule;
use DevRavik\LaravelLicensing\Models\License;
use DevRavik\LaravelLicensing\Events\LicenseExpired;

Schedule::call(function () {
    License::query()
        ->whereNull('revoked_at')
        ->whereNotNull('expires_at')
        ->where('expires_at', '', now());
    })
    ->get();
```

### Custom License Model

[](#custom-license-model)

```
// app/Models/License.php
namespace App\Models;

use DevRavik\LaravelLicensing\Models\License as BaseLicense;

class License extends BaseLicense
{
    public function getIsPremiumAttribute(): bool
    {
        return in_array($this->product, ['pro', 'enterprise']);
    }
}
```

Update `config/license.php`:

```
'license_model' => \App\Models\License::class,
```

### Custom Activation Model

[](#custom-activation-model)

```
namespace App\Models;

use DevRavik\LaravelLicensing\Models\Activation as BaseActivation;

class Activation extends BaseActivation
{
    // Add custom attributes or relationships
}
```

```
'activation_model' => \App\Models\Activation::class,
```

### Using in Controllers

[](#using-in-controllers)

```
public function activate(Request $request)
{
    $request->validate(['key' => 'required|string', 'binding' => 'required|string']);

    try {
        $activation = License::activate($request->key, $request->binding);

        return response()->json(['activated' => true, 'binding' => $activation->binding]);
    } catch (LicenseManagerException $e) {
        return response()->json(['error' => $e->getMessage()], $e->getStatusCode());
    }
}
```

---

Security
--------

[](#security)

- **Key generation** uses `random_bytes()` a cryptographically secure CSPRNG. No `openssl` extension required.
- **Key storage** keys are hashed with bcrypt via Laravel's `Hash` facade before being written to the database. The raw key is never persisted. A SHA-256 `lookup_token` is stored alongside to enable fast lookups without a full-table bcrypt scan.
- **Key comparison** uses `Hash::check()`, which is resistant to timing attacks.
- **One-time retrieval** the raw key is available only during the `create()` call. Transmit it to the end user immediately over a secure channel (HTTPS).
- **Signature-based verification (v1.1+)** optional Ed25519 signature-based license verification for offline and tamper-resistant validation scenarios. When enabled, license keys contain cryptographically signed payloads that can be verified without database access.

**Production checklist:**

1. Keep `hash_keys = true` never disable in production.
2. Use HTTPS for all endpoints that transmit or receive license keys.
3. Rate-limit validation and activation endpoints to prevent brute-force guessing.
4. Use the provided events to audit all license operations.
5. Never log raw license keys.
6. For signed licenses, store private keys securely and never commit them to version control.

---

Testing
-------

[](#testing)

The package test suite runs against MySQL:

```
# MySQL
TEST_DB_DRIVER=mysql \
TEST_DB_HOST=127.0.0.1 \
TEST_DB_PORT=3306 \
TEST_DB_DATABASE=laravel_licensing_test \
TEST_DB_USERNAME=root \
TEST_DB_PASSWORD=secret \
vendor/bin/phpunit
```

Create the MySQL test database first:

```
mysql -u root -e "CREATE DATABASE IF NOT EXISTS laravel_licensing_test;"
```

### Example Test

[](#example-test)

```
use DevRavik\LaravelLicensing\Facades\License;
use DevRavik\LaravelLicensing\Exceptions\SeatLimitExceededException;

public function test_seat_limit_is_enforced(): void
{
    $license = License::for(User::factory()->create())
        ->product('pro')
        ->seats(2)
        ->create();

    $key = $license->key;

    License::activate($key, 'domain-1.com');
    License::activate($key, 'domain-2.com');

    $this->expectException(SeatLimitExceededException::class);
    License::activate($key, 'domain-3.com');
}
```

---

Signature-Based License Verification (v1.1+)
--------------------------------------------

[](#signature-based-license-verification-v11)

v1.1 adds optional Ed25519 signature-based license verification for offline and tamper-resistant validation scenarios.

### Enabling Signed Licenses

[](#enabling-signed-licenses)

Set `LICENSE_GENERATION=signed` in your `.env` file and provide Ed25519 key pair:

```
LICENSE_GENERATION=signed
LICENSE_PUBLIC_KEY=base64_encoded_public_key
LICENSE_PRIVATE_KEY=base64_encoded_private_key
```

Or use file paths:

```
LICENSE_GENERATION=signed
LICENSE_PUBLIC_KEY=/path/to/public.key
LICENSE_PRIVATE_KEY=/path/to/private.key
```

### Generating Key Pairs

[](#generating-key-pairs)

Generate an Ed25519 key pair using the Artisan command:

```
php artisan licensing:keys
```

This will generate a new key pair and display the values to add to your `.env` file.

**Options:**

- `--force` - Overwrite existing keys if they already exist
- `--show` - Display the generated keys in the console
- `--write` - Automatically append keys to your `.env` file

**Example:**

```
# Generate and display keys
php artisan licensing:keys --show

# Generate and auto-write to .env
php artisan licensing:keys --write

# Overwrite existing keys
php artisan licensing:keys --force
```

**Manual Generation (Alternative):**

If you prefer to generate keys manually using PHP:

```
$keypair = sodium_crypto_sign_keypair();
$publicKey = base64_encode(sodium_crypto_sign_publickey($keypair));
$privateKey = base64_encode(sodium_crypto_sign_secretkey($keypair));

// Store these securely
echo "Public Key: {$publicKey}\n";
echo "Private Key: {$privateKey}\n";
```

### How It Works

[](#how-it-works)

When `license_generation` is set to `'signed'`:

1. **Generation**: License keys are created by signing a JSON payload (product, seats, expiry, owner info) with the private key using Ed25519.
2. **Format**: Keys are base64-encoded strings containing `base64(message . '.' . signature)`.
3. **Verification**: During validation, the signature is verified using the public key before database lookup.
4. **Storage**: Signed licenses are still stored in the database (hashed) for seat management, activations, and revocation tracking.

### Benefits

[](#benefits)

- **Offline validation**: Verify license authenticity without database access
- **Tamper resistance**: Any modification to the license key invalidates the signature
- **Cryptographic proof**: Ed25519 provides strong cryptographic guarantees
- **Backward compatible**: Default behavior remains random generation

### Example

[](#example)

```
// Generate signed license
$license = License::for($user)
    ->product('pro')
    ->seats(5)
    ->expiresInDays(365)
    ->create();

// Validate (signature verified automatically)
$validated = License::validate($license->key);
```

---

Changelog
---------

[](#changelog)

Please see [CHANGELOG.md](CHANGELOG.md) for a full release history.

---

Contributing
------------

[](#contributing)

Contributions are welcome. Please:

1. Fork the repository and create a feature branch from `main`.
2. Write tests for all new functionality.
3. Follow [PSR-12](https://www.php-fig.org/psr/psr-12/) and run `composer format` before submitting.
4. Ensure `composer test` and `composer analyse` pass.
5. Open a pull request with a clear description of the change.

Pull requests without tests will not be merged.

When reporting a bug, please include your PHP and Laravel version, the package version, steps to reproduce, and any relevant stack traces.

---

Security Vulnerabilities
------------------------

[](#security-vulnerabilities)

Please do **not** report security vulnerabilities via GitHub Issues. Email `dev.ravikgupt@gmail.com` with the subject line `[SECURITY] devravik/laravel-licensing  `. You will receive a response within 48 hours.

See [SECURITY.md](SECURITY.md) for details.

---

Maintainer
----------

[](#maintainer)

**Ravi K Gupta**

- **Website**: [devravik.github.io](https://devravik.github.io/)
- **Email**: `dev.ravikgupt@gmail.com`
- **LinkedIn**: [linkedin.com/in/ravi-k-dev](https://www.linkedin.com/in/ravi-k-dev)
- **GitHub**: [github.com/devravik](https://github.com/devravik)

---

License
-------

[](#license)

The MIT License (MIT). Please see [LICENSE](LICENSE) for more information.

###  Health Score

39

—

LowBetter than 86% of packages

Maintenance85

Actively maintained with recent releases

Popularity12

Limited adoption so far

Community8

Small or concentrated contributor base

Maturity44

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~0 days

Total

2

Last Release

75d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/c69a2178f675306ed080128015c804a2281f827a3cbf2909e96fb9c02d623549?d=identicon)[devravik](/maintainers/devravik)

---

Top Contributors

[![devravik](https://avatars.githubusercontent.com/u/41594847?v=4)](https://github.com/devravik "devravik (21 commits)")

---

Tags

laravellicenseactivationlicensingsoftware licenseseat-based

###  Code Quality

TestsPHPUnit

Static AnalysisPHPStan

Code StyleLaravel Pint

### Embed Badge

![Health badge](/badges/devravik-laravel-licensing/health.svg)

```
[![Health](https://phpackages.com/badges/devravik-laravel-licensing/health.svg)](https://phpackages.com/packages/devravik-laravel-licensing)
```

###  Alternatives

[roots/acorn

Framework for Roots WordPress projects built with Laravel components.

9682.1M97](/packages/roots-acorn)[laravel/pulse

Laravel Pulse is a real-time application performance monitoring tool and dashboard for your Laravel application.

1.7k12.1M99](/packages/laravel-pulse)[laravel/cashier

Laravel Cashier provides an expressive, fluent interface to Stripe's subscription billing services.

2.5k25.9M107](/packages/laravel-cashier)[psalm/plugin-laravel

Psalm plugin for Laravel

3274.9M308](/packages/psalm-plugin-laravel)[aedart/athenaeum

Athenaeum is a mono repository; a collection of various PHP packages

245.2k](/packages/aedart-athenaeum)[flarum/core

Delightfully simple forum software.

211.3M1.9k](/packages/flarum-core)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)