Laravel Cashier (Paddle)

• Introduction

• Upgrading Cashier

• Installation

  • Paddle Sandbox

• Configuration

  • Billable Model
  • API Keys
  • Paddle JS
  • Currency Configuration
  • Overriding Default Models

• Quickstart

  • Selling Products
  • Selling Subscriptions

• Checkout Sessions

  • Overlay Checkout
  • Inline Checkout
  • Guest Checkouts

• Price Previews

  • Customer Price Previews
  • Discounts

• Customers

  • Customer Defaults
  • Retrieving Customers
  • Creating Customers

• Subscriptions

  • Creating Subscriptions
  • Checking Subscription Status
  • Subscription Single Charges
  • Updating Payment Information
  • Changing Plans
  • Subscription Quantity
  • Subscriptions With Multiple Products
  • Multiple Subscriptions
  • Pausing Subscriptions
  • Canceling Subscriptions

• Subscription Trials

  • With Payment Method Up Front
  • Without Payment Method Up Front
  • Extend or Activate a Trial

• Handling Paddle Webhooks

  • Defining Webhook Event Handlers
  • Verifying Webhook Signatures

• Single Charges

  • Charging for Products
  • Refunding Transactions
  • Crediting Transactions

• Transactions

  • Past and Upcoming Payments

• Testing

Introduction

Laravel Cashier Paddle provides an expressive, fluent interface to Paddle's subscription billing services. It handles almost all of the boilerplate subscription billing code you are dreading. In addition to basic subscription management, Cashier can handle: swapping subscriptions, subscription "quantities", subscription pausing, cancelation grace periods, and more.

Before digging into Cashier Paddle, we recommend you also review Paddle's concept guides and API documentation.

Upgrading Cashier

When upgrading to a new version of Cashier, it's important that you carefully review the upgrade guide.

Installation

First, install the Cashier package for Paddle using the Composer package manager:

1composer require laravel/cashier-paddle
1composer require laravel/cashier-paddle

Next, you should publish the Cashier migration files using the vendor:publish Artisan command:

1php artisan vendor:publish --tag="cashier-migrations"
1php artisan vendor:publish --tag="cashier-migrations"

Then, you should run your application's database migrations. The Cashier migrations will create a new customers table. In addition, new subscriptions and subscription_items tables will be created to store all of your customer's subscriptions. Lastly, a new transactions table will be created to store all of the Paddle transactions associated with your customers:

1php artisan migrate
1php artisan migrate

Paddle Sandbox

During local and staging development, you should register a Paddle Sandbox account. This account will give you a sandboxed environment to test and develop your applications without making actual payments. You may use Paddle's test card numbers to simulate various payment scenarios.

When using the Paddle Sandbox environment, you should set the PADDLE_SANDBOX environment variable to true within your application's .env file:

1PADDLE_SANDBOX=true
1PADDLE_SANDBOX=true

After you have finished developing your application you may apply for a Paddle vendor account. Before your application is placed into production, Paddle will need to approve your application's domain.

Configuration

Billable Model

Before using Cashier, you must add the Billable trait to your user model definition. This trait provides various methods to allow you to perform common billing tasks, such as creating subscriptions and updating payment method information:

1use Laravel\Paddle\Billable;
2 
3class User extends Authenticatable
4{
5    use Billable;
6}
1use Laravel\Paddle\Billable;
2 
3class User extends Authenticatable
4{
5    use Billable;
6}

If you have billable entities that are not users, you may also add the trait to those classes:

1use Illuminate\Database\Eloquent\Model;
2use Laravel\Paddle\Billable;
3 
4class Team extends Model
5{
6    use Billable;
7}
1use Illuminate\Database\Eloquent\Model;
2use Laravel\Paddle\Billable;
3 
4class Team extends Model
5{
6    use Billable;
7}

API Keys

Next, you should configure your Paddle keys in your application's .env file. You can retrieve your Paddle API keys from the Paddle control panel:

1PADDLE_CLIENT_SIDE_TOKEN=your-paddle-client-side-token
2PADDLE_API_KEY=your-paddle-api-key
3PADDLE_RETAIN_KEY=your-paddle-retain-key
4PADDLE_WEBHOOK_SECRET="your-paddle-webhook-secret"
5PADDLE_SANDBOX=true
1PADDLE_CLIENT_SIDE_TOKEN=your-paddle-client-side-token
2PADDLE_API_KEY=your-paddle-api-key
3PADDLE_RETAIN_KEY=your-paddle-retain-key
4PADDLE_WEBHOOK_SECRET="your-paddle-webhook-secret"
5PADDLE_SANDBOX=true

The PADDLE_SANDBOX environment variable should be set to true when you are using Paddle's Sandbox environment. The PADDLE_SANDBOX variable should be set to false if you are deploying your application to production and are using Paddle's live vendor environment.

The PADDLE_RETAIN_KEY is optional and should only be set if you're using Paddle with Retain.

Paddle JS

Paddle relies on its own JavaScript library to initiate the Paddle checkout widget. You can load the JavaScript library by placing the @paddleJS Blade directive right before your application layout's closing </head> tag:

1<head>
2    ...
3 
4    @paddleJS
5</head>
1<head>
2    ...
3 
4    @paddleJS
5</head>

Currency Configuration

You can specify a locale to be used when formatting money values for display on invoices. Internally, Cashier utilizes PHP's NumberFormatter class class to set the currency locale:

1CASHIER_CURRENCY_LOCALE=nl_BE
1CASHIER_CURRENCY_LOCALE=nl_BE

Overriding Default Models

You are free to extend the models used internally by Cashier by defining your own model and extending the corresponding Cashier model:

1use Laravel\Paddle\Subscription as CashierSubscription;
2 
3class Subscription extends CashierSubscription
4{
5    // ...
6}
1use Laravel\Paddle\Subscription as CashierSubscription;
2 
3class Subscription extends CashierSubscription
4{
5    // ...
6}

After defining your model, you may instruct Cashier to use your custom model via the Laravel\Paddle\Cashier class. Typically, you should inform Cashier about your custom models in the boot method of your application's App\Providers\AppServiceProvider class:

 1use App\Models\Cashier\Subscription;
 2use App\Models\Cashier\Transaction;
 3 
 4/**
 5 * Bootstrap any application services.
 6 */
 7public function boot(): void
 8{
 9    Cashier::useSubscriptionModel(Subscription::class);
10    Cashier::useTransactionModel(Transaction::class);
11}
 1use App\Models\Cashier\Subscription;
 2use App\Models\Cashier\Transaction;
 3 
 4/**
 5 * Bootstrap any application services.
 6 */
 7public function boot(): void
 8{
 9    Cashier::useSubscriptionModel(Subscription::class);
10    Cashier::useTransactionModel(Transaction::class);
11}

Quickstart

Selling Products

Offering product and subscription billing via your application can be intimidating. However, thanks to Cashier and Paddle's Checkout Overlay, you can easily build modern, robust payment integrations.

To charge customers for non-recurring, single-charge products, we'll utilize Cashier to charge customers with Paddle's Checkout Overlay, where they will provide their payment details and confirm their purchase. Once the payment has been made via the Checkout Overlay, the customer will be redirected to a success URL of your choosing within your application:

1use Illuminate\Http\Request;
2 
3Route::get('/buy', function (Request $request) {
4    $checkout = $request->user()->checkout('pri_deluxe_album')
5        ->returnTo(route('dashboard'));
6 
7    return view('buy', ['checkout' => $checkout]);
8})->name('checkout');
1use Illuminate\Http\Request;
2 
3Route::get('/buy', function (Request $request) {
4    $checkout = $request->user()->checkout('pri_deluxe_album')
5        ->returnTo(route('dashboard'));
6 
7    return view('buy', ['checkout' => $checkout]);
8})->name('checkout');

As you can see in the example above, we will utilize Cashier's provided checkout method to create a checkout object to present the customer the Paddle Checkout Overlay for a given "price identifier". When using Paddle, "prices" refer to defined prices for specific products.

If necessary, the checkout method will automatically create a customer in Paddle and connect that Paddle customer record to the corresponding user in your application's database. After completing the checkout session, the customer will be redirected to a dedicated success page where you can display an informational message to the customer.

In the buy view, we will include a button to display the Checkout Overlay. The paddle-button Blade component is included with Cashier Paddle; however, you may also manually render an overlay checkout:

1<x-paddle-button :checkout="$checkout" class="px-8 py-4">
2    Buy Product
3</x-paddle-button>
1<x-paddle-button :checkout="$checkout" class="px-8 py-4">
2    Buy Product
3</x-paddle-button>

Providing Meta Data to Paddle Checkout

When selling products, it's common to keep track of completed orders and purchased products via Cart and Order models defined by your own application. When redirecting customers to Paddle's Checkout Overlay to complete a purchase, you may need to provide an existing order identifier so that you can associate the completed purchase with the corresponding order when the customer is redirected back to your application.

To accomplish this, you may provide an array of custom data to the checkout method. Let's imagine that a pending Order is created within our application when a user begins the checkout process. Remember, the Cart and Order models in this example are illustrative and not provided by Cashier. You are free to implement these concepts based on the needs of your own application:

 1use App\Models\Cart;
 2use App\Models\Order;
 3use Illuminate\Http\Request;
 4 
 5Route::get('/cart/{cart}/checkout', function (Request $request, Cart $cart) {
 6    $order = Order::create([
 7        'cart_id' => $cart->id,
 8        'price_ids' => $cart->price_ids,
 9        'status' => 'incomplete',
10    ]);
11 
12    $checkout = $request->user()->checkout($order->price_ids)
13        ->customData(['order_id' => $order->id]);
14 
15    return view('billing', ['checkout' => $checkout]);
16})->name('checkout');
 1use App\Models\Cart;
 2use App\Models\Order;
 3use Illuminate\Http\Request;
 4 
 5Route::get('/cart/{cart}/checkout', function (Request $request, Cart $cart) {
 6    $order = Order::create([
 7        'cart_id' => $cart->id,
 8        'price_ids' => $cart->price_ids,
 9        'status' => 'incomplete',
10    ]);
11 
12    $checkout = $request->user()->checkout($order->price_ids)
13        ->customData(['order_id' => $order->id]);
14 
15    return view('billing', ['checkout' => $checkout]);
16})->name('checkout');

As you can see in the example above, when a user begins the checkout process, we will provide all of the cart / order's associated Paddle price identifiers to the checkout method. Of course, your application is responsible for associating these items with the "shopping cart" or order as a customer adds them. We also provide the order's ID to the Paddle Checkout Overlay via the customData method.

Of course, you will likely want to mark the order as "complete" once the customer has finished the checkout process. To accomplish this, you may listen to the webhooks dispatched by Paddle and raised via events by Cashier to store order information in your database.

To get started, listen for the TransactionCompleted event dispatched by Cashier. Typically, you should register the event listener in the boot method of one of your application's service providers:

 1use App\Listeners\CompleteOrder;
 2use Illuminate\Support\Facades\Event;
 3use Laravel\Paddle\Events\TransactionCompleted;
 4 
 5/**
 6 * Bootstrap any application services.
 7 */
 8public function boot(): void
 9{
10    Event::listen(TransactionCompleted::class, CompleteOrder::class);
11}
 1use App\Listeners\CompleteOrder;
 2use Illuminate\Support\Facades\Event;
 3use Laravel\Paddle\Events\TransactionCompleted;
 4 
 5/**
 6 * Bootstrap any application services.
 7 */
 8public function boot(): void
 9{
10    Event::listen(TransactionCompleted::class, CompleteOrder::class);
11}

In this example, the CompleteOrder listener might look like the following:

 1namespace App\Listeners;
 2 
 3use App\Models\Order;
 4use Laravel\Cashier\Cashier;
 5use Laravel\Cashier\Events\TransactionCompleted;
 6 
 7class CompleteOrder
 8{
 9    /**
10     * Handle the incoming Cashier webhook event.
11     */
12    public function handle(TransactionCompleted $event): void
13    {
14        $orderId = $event->payload['data']['custom_data']['order_id'] ?? null;
15 
16        $order = Order::findOrFail($orderId);
17 
18        $order->update(['status' => 'completed']);
19    }
20}
 1namespace App\Listeners;
 2 
 3use App\Models\Order;
 4use Laravel\Cashier\Cashier;
 5use Laravel\Cashier\Events\TransactionCompleted;
 6 
 7class CompleteOrder
 8{
 9    /**
10     * Handle the incoming Cashier webhook event.
11     */
12    public function handle(TransactionCompleted $event): void
13    {
14        $orderId = $event->payload['data']['custom_data']['order_id'] ?? null;
15 
16        $order = Order::findOrFail($orderId);
17 
18        $order->update(['status' => 'completed']);
19    }
20}

Please refer to Paddle's documentation for more information on the data contained by the transaction.completed event.

Selling Subscriptions

Offering product and subscription billing via your application can be intimidating. However, thanks to Cashier and Paddle's Checkout Overlay, you can easily build modern, robust payment integrations.

To learn how to sell subscriptions using Cashier and Paddle's Checkout Overlay, let's consider the simple scenario of a subscription service with a basic monthly (price_basic_monthly) and yearly (price_basic_yearly) plan. These two prices could be grouped under a "Basic" product (pro_basic) in our Paddle dashboard. In addition, our subscription service might offer an Expert plan as pro_expert.

First, let's discover how a customer can subscribe to our services. Of course, you can imagine the customer might click a "subscribe" button for the Basic plan on our application's pricing page. This button will invoke a Paddle Checkout Overlay for their chosen plan. To get started, let's initiate a checkout session via the checkout method:

1use Illuminate\Http\Request;
2 
3Route::get('/subscribe', function (Request $request) {
4    $checkout = $request->user()->checkout('price_basic_monthly')
5        ->returnTo(route('dashboard'));
6 
7    return view('subscribe', ['checkout' => $checkout]);
8})->name('subscribe');
1use Illuminate\Http\Request;
2 
3Route::get('/subscribe', function (Request $request) {
4    $checkout = $request->user()->checkout('price_basic_monthly')
5        ->returnTo(route('dashboard'));
6 
7    return view('subscribe', ['checkout' => $checkout]);
8})->name('subscribe');

In the subscribe view, we will include a button to display the Checkout Overlay. The paddle-button Blade component is included with Cashier Paddle; however, you may also manually render an overlay checkout:

1<x-paddle-button :checkout="$checkout" class="px-8 py-4">
2    Subscribe
3</x-paddle-button>
1<x-paddle-button :checkout="$checkout" class="px-8 py-4">
2    Subscribe
3</x-paddle-button>

Now, when the Subscribe button is clicked, the customer will be able to enter their payment details and initiate their subscription. To know when their subscription has actually started (since some payment methods require a few seconds to process), you should also configure Cashier's webhook handling.

Now that customers can start subscriptions, we need to restrict certain portions of our application so that only subscribed users can access them. Of course, we can always determine a user's current subscription status via the subscribed method provided by Cashier's Billable trait:

1@if ($user->subscribed())
2    <p>You are subscribed.</p>
3@endif
1@if ($user->subscribed())
2    <p>You are subscribed.</p>
3@endif

We can even easily determine if a user is subscribed to specific product or price:

1@if ($user->subscribedToProduct('pro_basic'))
2    <p>You are subscribed to our Basic product.</p>
3@endif
4 
5@if ($user->subscribedToPrice('price_basic_monthly'))
6    <p>You are subscribed to our monthly Basic plan.</p>
7@endif
1@if ($user->subscribedToProduct('pro_basic'))
2    <p>You are subscribed to our Basic product.</p>
3@endif
4 
5@if ($user->subscribedToPrice('price_basic_monthly'))
6    <p>You are subscribed to our monthly Basic plan.</p>
7@endif

Building a Subscribed Middleware

For convenience, you may wish to create a middleware which determines if the incoming request is from a subscribed user. Once this middleware has been defined, you may easily assign it to a route to prevent users that are not subscribed from accessing the route:

 1<?php
 2 
 3namespace App\Http\Middleware;
 4 
 5use Closure;
 6use Illuminate\Http\Request;
 7use Symfony\Component\HttpFoundation\Response;
 8 
 9class Subscribed
10{
11    /**
12     * Handle an incoming request.
13     */
14    public function handle(Request $request, Closure $next): Response
15    {
16        if (! $request->user()?->subscribed()) {
17            // Redirect user to billing page and ask them to subscribe...
18            return redirect('/subscribe');
19        }
20 
21        return $next($request);
22    }
23}
 1<?php
 2 
 3namespace App\Http\Middleware;
 4 
 5use Closure;
 6use Illuminate\Http\Request;
 7use Symfony\Component\HttpFoundation\Response;
 8 
 9class Subscribed
10{
11    /**
12     * Handle an incoming request.
13     */
14    public function handle(Request $request, Closure $next): Response
15    {
16        if (! $request->user()?->subscribed()) {
17            // Redirect user to billing page and ask them to subscribe...
18            return redirect('/subscribe');
19        }
20 
21        return $next($request);
22    }
23}

Once the middleware has been defined, you may assign it to a route:

1use App\Http\Middleware\Subscribed;
2 
3Route::get('/dashboard', function () {
4    // ...
5})->middleware([Subscribed::class]);
1use App\Http\Middleware\Subscribed;
2 
3Route::get('/dashboard', function () {
4    // ...
5})->middleware([Subscribed::class]);

Allowing Customers to Manage Their Billing Plan

Of course, customers may want to change their subscription plan to another product or "tier". In our example from above, we'd want to allow the customer to change their plan from a monthly subscription to a yearly subscription. For this you'll need to implement something like a button that leads to the below route:

1use Illuminate\Http\Request;
2 
3Route::put('/subscription/{price}/swap', function (Request $request, $price) {
4    $user->subscription()->swap($price); // With "$price" being "price_basic_yearly" for this example.
5 
6    return redirect()->route('dashboard');
7})->name('subscription.swap');
1use Illuminate\Http\Request;
2 
3Route::put('/subscription/{price}/swap', function (Request $request, $price) {
4    $user->subscription()->swap($price); // With "$price" being "price_basic_yearly" for this example.
5 
6    return redirect()->route('dashboard');
7})->name('subscription.swap');

Besides swapping plans you'll also need to allow your customers to cancel their subscription. Like swapping plans, provide a button that leads to the following route:

1use Illuminate\Http\Request;
2 
3Route::put('/subscription/cancel', function (Request $request, $price) {
4    $user->subscription()->cancel();
5 
6    return redirect()->route('dashboard');
7})->name('subscription.cancel');
1use Illuminate\Http\Request;
2 
3Route::put('/subscription/cancel', function (Request $request, $price) {
4    $user->subscription()->cancel();
5 
6    return redirect()->route('dashboard');
7})->name('subscription.cancel');

And now your subscription will get cancelled at the end of its billing period.

Checkout Sessions

Most operations to bill customers are performed using "checkouts" via Paddle's Checkout Overlay widget or by utilizing inline checkout.

Before processing checkout payments using Paddle, you should define your application's default payment link in your Paddle checkout settings dashboard.

Overlay Checkout

Before displaying the Checkout Overlay widget, you must generate a checkout session using Cashier. A checkout session will inform the checkout widget of the billing operation that should be performed:

1use Illuminate\Http\Request;
2 
3Route::get('/buy', function (Request $request) {
4    $checkout = $user->checkout('pri_34567')
5        ->returnTo(route('dashboard'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});
1use Illuminate\Http\Request;
2 
3Route::get('/buy', function (Request $request) {
4    $checkout = $user->checkout('pri_34567')
5        ->returnTo(route('dashboard'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});

Cashier includes a paddle-button Blade component. You may pass the checkout session to this component as a "prop". Then, when this button is clicked, Paddle's checkout widget will be displayed:

1<x-paddle-button :checkout="$checkout" class="px-8 py-4">
2    Subscribe
3</x-paddle-button>
1<x-paddle-button :checkout="$checkout" class="px-8 py-4">
2    Subscribe
3</x-paddle-button>

By default, this will display the widget using Paddle's default styling. You can customize the widget by adding Paddle supported attributes like the data-theme='light' attribute to the component:

1<x-paddle-button :url="$payLink" class="px-8 py-4" data-theme="light">
2    Subscribe
3</x-paddle-button>
1<x-paddle-button :url="$payLink" class="px-8 py-4" data-theme="light">
2    Subscribe
3</x-paddle-button>

The Paddle checkout widget is asynchronous. Once the user creates a subscription within the widget, Paddle will send your application a webhook so that you may properly update the subscription state in your application's database. Therefore, it's important that you properly set up webhooks to accommodate for state changes from Paddle.

Manually Rendering an Overlay Checkout

You may also manually render an overlay checkout without using Laravel's built-in Blade components. To get started, generate the checkout session as demonstrated in previous examples:

1use Illuminate\Http\Request;
2 
3Route::get('/buy', function (Request $request) {
4    $checkout = $user->checkout('pri_34567')
5        ->returnTo(route('dashboard'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});
1use Illuminate\Http\Request;
2 
3Route::get('/buy', function (Request $request) {
4    $checkout = $user->checkout('pri_34567')
5        ->returnTo(route('dashboard'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});

Next, you may use Paddle.js to initialize the checkout. In this example, we will create a link that is assigned the paddle_button class. Paddle.js will detect this class and display the overlay checkout when the link is clicked:

 1<?php
 2$items = $checkout->getItems();
 3$customer = $checkout->getCustomer();
 4$custom = $checkout->getCustomData();
 5?>
 6 
 7<a
 8    href='#!'
 9    class='paddle_button'
10    data-items='{!! json_encode($items) !!}'
11    @if ($customer) data-customer-id='{{ $customer->paddle_id }}' @endif
12    @if ($custom) data-custom-data='{{ json_encode($custom) }}' @endif
13    @if ($returnUrl = $checkout->getReturnUrl()) data-success-url='{{ $returnUrl }}' @endif
14>
15    Buy Product
16</a>
 1<?php
 2$items = $checkout->getItems();
 3$customer = $checkout->getCustomer();
 4$custom = $checkout->getCustomData();
 5?>
 6 
 7<a
 8    href='#!'
 9    class='paddle_button'
10    data-items='{!! json_encode($items) !!}'
11    @if ($customer) data-customer-id='{{ $customer->paddle_id }}' @endif
12    @if ($custom) data-custom-data='{{ json_encode($custom) }}' @endif
13    @if ($returnUrl = $checkout->getReturnUrl()) data-success-url='{{ $returnUrl }}' @endif
14>
15    Buy Product
16</a>

Inline Checkout

If you don't want to make use of Paddle's "overlay" style checkout widget, Paddle also provides the option to display the widget inline. While this approach does not allow you to adjust any of the checkout's HTML fields, it allows you to embed the widget within your application.

To make it easy for you to get started with inline checkout, Cashier includes a paddle-checkout Blade component. To get started, you should generate a checkout session:

1use Illuminate\Http\Request;
2 
3Route::get('/buy', function (Request $request) {
4    $checkout = $user->checkout('pri_34567')
5        ->returnTo(route('dashboard'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});
1use Illuminate\Http\Request;
2 
3Route::get('/buy', function (Request $request) {
4    $checkout = $user->checkout('pri_34567')
5        ->returnTo(route('dashboard'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});

Then, you may pass the checkout session to the component's checkout attribute:

1<x-paddle-checkout :checkout="$checkout" class="w-full" />
1<x-paddle-checkout :checkout="$checkout" class="w-full" />

To adjust the height of the inline checkout component, you may pass the height attribute to the Blade component:

1<x-paddle-checkout :checkout="$checkout" class="w-full" height="500" />
1<x-paddle-checkout :checkout="$checkout" class="w-full" height="500" />

Please consult Paddle's guide on Inline Checkout and available checkout settings for further details on the inline checkout's customization options.

Manually Rendering an Inline Checkout

You may also manually render an inline checkout without using Laravel's built-in Blade components. To get started, generate the checkout session as demonstrated in previous examples:

1use Illuminate\Http\Request;
2 
3Route::get('/buy', function (Request $request) {
4    $checkout = $user->checkout('pri_34567')
5        ->returnTo(route('dashboard'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});
1use Illuminate\Http\Request;
2 
3Route::get('/buy', function (Request $request) {
4    $checkout = $user->checkout('pri_34567')
5        ->returnTo(route('dashboard'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});

Next, you may use Paddle.js to initialize the checkout. In this example, we will demonstrate this using Alpine.js; however, you are free to modify this example for your own frontend stack:

 1<?php
 2$options = $checkout->options();
 3 
 4$options['settings']['frameTarget'] = 'paddle-checkout';
 5$options['settings']['frameInitialHeight'] = 366;
 6?>
 7 
 8<div class="paddle-checkout" x-data="{}" x-init="
 9    Paddle.Checkout.open(@json($options));
10">
11</div>
 1<?php
 2$options = $checkout->options();
 3 
 4$options['settings']['frameTarget'] = 'paddle-checkout';
 5$options['settings']['frameInitialHeight'] = 366;
 6?>
 7 
 8<div class="paddle-checkout" x-data="{}" x-init="
 9    Paddle.Checkout.open(@json($options));
10">
11</div>

Guest Checkouts

Sometimes, you may need to create a checkout session for users that do not need an account with your application. To do so, you may use the guest method:

1use Illuminate\Http\Request;
2use Laravel\Paddle\Checkout;
3 
4Route::get('/buy', function (Request $request) {
5    $checkout = Checkout::guest('pri_34567')
6        ->returnTo(route('home'));
7 
8    return view('billing', ['checkout' => $checkout]);
9});
1use Illuminate\Http\Request;
2use Laravel\Paddle\Checkout;
3 
4Route::get('/buy', function (Request $request) {
5    $checkout = Checkout::guest('pri_34567')
6        ->returnTo(route('home'));
7 
8    return view('billing', ['checkout' => $checkout]);
9});

Then, you may provide the checkout session to the Paddle button or inline checkout Blade components.

Price Previews

Paddle allows you to customize prices per currency, essentially allowing you to configure different prices for different countries. Cashier Paddle allows you to retrieve all of these prices using the previewPrices method. This method accepts the price IDs you wish to retrieve prices for:

1use Laravel\Paddle\Cashier;
2 
3$prices = Cashier::previewPrices(['pri_123', 'pri_456']);
1use Laravel\Paddle\Cashier;
2 
3$prices = Cashier::previewPrices(['pri_123', 'pri_456']);

The currency will be determined based on the IP address of the request; however, you may optionally provide a specific country to retrieve prices for:

1use Laravel\Paddle\Cashier;
2 
3$prices = Cashier::productPrices(['pri_123', 'pri_456'], ['address' => [
4    'country_code' => 'BE',
5    'postal_code' => '1234',
6]]);
1use Laravel\Paddle\Cashier;
2 
3$prices = Cashier::productPrices(['pri_123', 'pri_456'], ['address' => [
4    'country_code' => 'BE',
5    'postal_code' => '1234',
6]]);

After retrieving the prices you may display them however you wish:

1<ul>
2    @foreach ($prices as $price)
3        <li>{{ $price->product['name'] }} - {{ $price->total() }}</li>
4    @endforeach
5</ul>
1<ul>
2    @foreach ($prices as $price)
3        <li>{{ $price->product['name'] }} - {{ $price->total() }}</li>
4    @endforeach
5</ul>

You may also display the subtotal price and tax amount separately:

1<ul>
2    @foreach ($prices as $price)
3        <li>{{ $price->product_title }} - {{ $price->subtotal() }} (+ {{ $price->tax() }} tax)</li>
4    @endforeach
5</ul>
1<ul>
2    @foreach ($prices as $price)
3        <li>{{ $price->product_title }} - {{ $price->subtotal() }} (+ {{ $price->tax() }} tax)</li>
4    @endforeach
5</ul>

For more information, checkout Paddle's API documentation regarding price previews.

Customer Price Previews

If a user is already a customer and you would like to display the prices that apply to that customer, you may do so by retrieving the prices directly from the customer instance:

1use App\Models\User;
2 
3$prices = User::find(1)->previewPrices(['pri_123', 'pri_456']);
1use App\Models\User;
2 
3$prices = User::find(1)->previewPrices(['pri_123', 'pri_456']);

Internally, Cashier will use the user's customer ID to retrieve the prices in their currency. So, for example, a user living in the United States will see prices in US dollars while a user in Belgium will see prices in Euros. If no matching currency can be found, the default currency of the product will be used. You can customize all prices of a product or subscription plan in the Paddle control panel.

Discounts

You may also choose to display prices after a discount. When calling the previewPrices method, you provide the discount ID via the discount_id option:

1use Laravel\Paddle\Cashier;
2 
3$prices = Cashier::previewPrices(['pri_123', 'pri_456'], [
4    'discount_id' => 'dsc_123'
5]);
1use Laravel\Paddle\Cashier;
2 
3$prices = Cashier::previewPrices(['pri_123', 'pri_456'], [
4    'discount_id' => 'dsc_123'
5]);

Then, display the calculated prices:

1<ul>
2    @foreach ($prices as $price)
3        <li>{{ $price->product['name'] }} - {{ $price->total() }}</li>
4    @endforeach
5</ul>
1<ul>
2    @foreach ($prices as $price)
3        <li>{{ $price->product['name'] }} - {{ $price->total() }}</li>
4    @endforeach
5</ul>

Customers

Customer Defaults

Cashier allows you to define some useful defaults for your customers when creating checkout sessions. Setting these defaults allow you to pre-fill a customer's email address and name so that they can immediately move on to the payment portion of the checkout widget. You can set these defaults by overriding the following methods on your billable model:

 1/**
 2 * Get the customer's name to associate with Paddle.
 3 */
 4public function paddleName(): string|null
 5{
 6    return $this->name;
 7}
 8 
 9/**
10 * Get the customer's email address to associate with Paddle.
11 */
12public function paddleEmail(): string|null
13{
14    return $this->email;
15}
 1/**
 2 * Get the customer's name to associate with Paddle.
 3 */
 4public function paddleName(): string|null
 5{
 6    return $this->name;
 7}
 8 
 9/**
10 * Get the customer's email address to associate with Paddle.
11 */
12public function paddleEmail(): string|null
13{
14    return $this->email;
15}

These defaults will be used for every action in Cashier that generates a checkout session.

Retrieving Customers

You can retrieve a customer by their Paddle Customer ID using the Cashier::findBillable method. This method will return an instance of the billable model:

1use Laravel\Cashier\Cashier;
2 
3$user = Cashier::findBillable($customerId);
1use Laravel\Cashier\Cashier;
2 
3$user = Cashier::findBillable($customerId);

Creating Customers

Occasionally, you may wish to create a Paddle customer without beginning a subscription. You may accomplish this using the createAsCustomer method:

1$customer = $user->createAsCustomer();
1$customer = $user->createAsCustomer();

An instance of Laravel\Paddle\Customer is returned. Once the customer has been created in Paddle, you may begin a subscription at a later date. You may provide an optional $options array to pass in any additional customer creation parameters that are supported by the Paddle API:

1$customer = $user->createAsCustomer($options);
1$customer = $user->createAsCustomer($options);

Subscriptions

Creating Subscriptions

To create a subscription, first retrieve an instance of your billable model from your database, which will typically be an instance of App\Models\User. Once you have retrieved the model instance, you may use the subscribe method to create the model's checkout session:

1use Illuminate\Http\Request;
2 
3Route::get('/user/subscribe', function (Request $request) {
4    $checkout = $request->user()->subscribe($premium = 12345, 'default')
5        ->returnTo(route('home'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});
1use Illuminate\Http\Request;
2 
3Route::get('/user/subscribe', function (Request $request) {
4    $checkout = $request->user()->subscribe($premium = 12345, 'default')
5        ->returnTo(route('home'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});

The first argument given to the subscribe method is the specific price the user is subscribing to. This value should correspond to the price's identifier in Paddle. The returnTo method accepts a URL that your user will be redirected to after they successfully complete the checkout. The second argument passed to the subscribe method should be the internal "type" of the subscription. If your application only offers a single subscription, you might call this default or primary. This subscription type is only for internal application usage and is not meant to be displayed to users. In addition, it should not contain spaces and it should never be changed after creating the subscription.

You may also provide an array of custom meta data regarding the subscription using the customData method:

1$checkout = $request->user()->subscribe($premium = 12345, 'default')
2    ->customData(['key' => 'value'])
3    ->returnTo(route('home'));
1$checkout = $request->user()->subscribe($premium = 12345, 'default')
2    ->customData(['key' => 'value'])
3    ->returnTo(route('home'));

Once a subscription checkout session has been created, the checkout session may be provided to the paddle-button Blade component that is included with Cashier Paddle:

1<x-paddle-button :checkout="$checkout" class="px-8 py-4">
2    Subscribe
3</x-paddle-button>
1<x-paddle-button :checkout="$checkout" class="px-8 py-4">
2    Subscribe
3</x-paddle-button>

After the user has finished their checkout, a subscription_created webhook will be dispatched from Paddle. Cashier will receive this webhook and setup the subscription for your customer. In order to make sure all webhooks are properly received and handled by your application, ensure you have properly setup webhook handling.

Checking Subscription Status

Once a user is subscribed to your application, you may check their subscription status using a variety of convenient methods. First, the subscribed method returns true if the user has an valid subscription, even if the subscription is currently within its trial period:

1if ($user->subscribed()) {
2    // ...
3}
1if ($user->subscribed()) {
2    // ...
3}

If your application offers multiple subscriptions, you may specify the subscription when invoking the subscribed method:

1if ($user->subscribed('default')) {
2    // ...
3}
1if ($user->subscribed('default')) {
2    // ...
3}

The subscribed method also makes a great candidate for a route middleware, allowing you to filter access to routes and controllers based on the user's subscription status:

 1<?php
 2 
 3namespace App\Http\Middleware;
 4 
 5use Closure;
 6use Illuminate\Http\Request;
 7use Symfony\Component\HttpFoundation\Response;
 8 
 9class EnsureUserIsSubscribed
10{
11    /**
12     * Handle an incoming request.
13     *
14     * @param  \Closure(\Illuminate\Http\Request): (\Symfony\Component\HttpFoundation\Response)  $next
15     */
16    public function handle(Request $request, Closure $next): Response
17    {
18        if ($request->user() && ! $request->user()->subscribed()) {
19            // This user is not a paying customer...
20            return redirect('billing');
21        }
22 
23        return $next($request);
24    }
25}
 1<?php
 2 
 3namespace App\Http\Middleware;
 4 
 5use Closure;
 6use Illuminate\Http\Request;
 7use Symfony\Component\HttpFoundation\Response;
 8 
 9class EnsureUserIsSubscribed
10{
11    /**
12     * Handle an incoming request.
13     *
14     * @param  \Closure(\Illuminate\Http\Request): (\Symfony\Component\HttpFoundation\Response)  $next
15     */
16    public function handle(Request $request, Closure $next): Response
17    {
18        if ($request->user() && ! $request->user()->subscribed()) {
19            // This user is not a paying customer...
20            return redirect('billing');
21        }
22 
23        return $next($request);
24    }
25}

If you would like to determine if a user is still within their trial period, you may use the onTrial method. This method can be useful for determining if you should display a warning to the user that they are still on their trial period:

1if ($user->subscription()->onTrial()) {
2    // ...
3}
1if ($user->subscription()->onTrial()) {
2    // ...
3}

The subscribedToPrice method may be used to determine if the user is subscribed to a given plan based on a given Paddle price ID. In this example, we will determine if the user's default subscription is actively subscribed to the monthly price:

1if ($user->subscribedToPrice($monthly = 'pri_123', 'default')) {
2    // ...
3}
1if ($user->subscribedToPrice($monthly = 'pri_123', 'default')) {
2    // ...
3}

The recurring method may be used to determine if the user is currently on an active subscription and is no longer within their trial period or on a grace period:

1if ($user->subscription()->recurring()) {
2    // ...
3}
1if ($user->subscription()->recurring()) {
2    // ...
3}

Canceled Subscription Status

To determine if the user was once an active subscriber but has canceled their subscription, you may use the canceled method:

1if ($user->subscription()->canceled()) {
2    // ...
3}
1if ($user->subscription()->canceled()) {
2    // ...
3}

You may also determine if a user has canceled their subscription, but are still on their "grace period" until the subscription fully expires. For example, if a user cancels a subscription on March 5th that was originally scheduled to expire on March 10th, the user is on their "grace period" until March 10th. In addition, the subscribed method will still return true during this time:

1if ($user->subscription()->onGracePeriod()) {
2    // ...
3}
1if ($user->subscription()->onGracePeriod()) {
2    // ...
3}

Past Due Status

If a payment fails for a subscription, it will be marked as past_due. When your subscription is in this state it will not be active until the customer has updated their payment information. You may determine if a subscription is past due using the pastDue method on the subscription instance:

1if ($user->subscription()->pastDue()) {
2    // ...
3}
1if ($user->subscription()->pastDue()) {
2    // ...
3}

When a subscription is past due, you should instruct the user to update their payment information.

If you would like subscriptions to still be considered valid when they are past_due, you may use the keepPastDueSubscriptionsActive method provided by Cashier. Typically, this method should be called in the register method of your AppServiceProvider:

1use Laravel\Paddle\Cashier;
2 
3/**
4 * Register any application services.
5 */
6public function register(): void
7{
8    Cashier::keepPastDueSubscriptionsActive();
9}
1use Laravel\Paddle\Cashier;
2 
3/**
4 * Register any application services.
5 */
6public function register(): void
7{
8    Cashier::keepPastDueSubscriptionsActive();
9}

Subscription Scopes

Most subscription states are also available as query scopes so that you may easily query your database for subscriptions that are in a given state:

1// Get all valid subscriptions...
2$subscriptions = Subscription::query()->valid()->get();
3 
4// Get all of the canceled subscriptions for a user...
5$subscriptions = $user->subscriptions()->canceled()->get();
1// Get all valid subscriptions...
2$subscriptions = Subscription::query()->valid()->get();
3 
4// Get all of the canceled subscriptions for a user...
5$subscriptions = $user->subscriptions()->canceled()->get();

A complete list of available scopes is available below:

 1Subscription::query()->valid();
 2Subscription::query()->onTrial();
 3Subscription::query()->expiredTrial();
 4Subscription::query()->notOnTrial();
 5Subscription::query()->active();
 6Subscription::query()->recurring();
 7Subscription::query()->pastDue();
 8Subscription::query()->paused();
 9Subscription::query()->notPaused();
10Subscription::query()->onPausedGracePeriod();
11Subscription::query()->notOnPausedGracePeriod();
12Subscription::query()->canceled();
13Subscription::query()->notCanceled();
14Subscription::query()->onGracePeriod();
15Subscription::query()->notOnGracePeriod();
 1Subscription::query()->valid();
 2Subscription::query()->onTrial();
 3Subscription::query()->expiredTrial();
 4Subscription::query()->notOnTrial();
 5Subscription::query()->active();
 6Subscription::query()->recurring();
 7Subscription::query()->pastDue();
 8Subscription::query()->paused();
 9Subscription::query()->notPaused();
10Subscription::query()->onPausedGracePeriod();
11Subscription::query()->notOnPausedGracePeriod();
12Subscription::query()->canceled();
13Subscription::query()->notCanceled();
14Subscription::query()->onGracePeriod();
15Subscription::query()->notOnGracePeriod();

Subscription Single Charges

Subscription single charges allow you to charge subscribers with a one-time charge on top of their subscriptions. You must provide one or multiple price ID's when invoking the charge method:

1// Charge a single price...
2$response = $user->subscription()->charge('pri_123');
3 
4// Charge multiple prices at once...
5$response = $user->subscription()->charge(['pri_123', 'pri_456']);
1// Charge a single price...
2$response = $user->subscription()->charge('pri_123');
3 
4// Charge multiple prices at once...
5$response = $user->subscription()->charge(['pri_123', 'pri_456']);

The charge method will not actually charge the customer until the next billing interval of their subscription. If you would like to bill the customer immediately, you may use the chargeAndInvoice method instead:

1$response = $user->subscription()->chargeAndInvoice('pri_123');
1$response = $user->subscription()->chargeAndInvoice('pri_123');

Updating Payment Information

Paddle always saves a payment method per subscription. If you want to update the default payment method for a subscription, you should redirect your customer to Paddle's hosted payment method update page using the redirectToUpdatePaymentMethod method on the subscription model:

1use Illuminate\Http\Request;
2 
3Route::get('/update-payment-method', function (Request $request) {
4    $user = $request->user();
5 
6    return $user->subscription()->redirectToUpdatePaymentMethod();
7});
1use Illuminate\Http\Request;
2 
3Route::get('/update-payment-method', function (Request $request) {
4    $user = $request->user();
5 
6    return $user->subscription()->redirectToUpdatePaymentMethod();
7});

When a user has finished updating their information, a subscription_updated webhook will be dispatched by Paddle and the subscription details will be updated in your application's database.

Changing Plans

After a user has subscribed to your application, they may occasionally want to change to a new subscription plan. To update the subscription plan for a user, you should pass the Paddle price's identifier to the subscription's swap method:

1use App\Models\User;
2 
3$user = User::find(1);
4 
5$user->subscription()->swap($premium = 'pri_456');
1use App\Models\User;
2 
3$user = User::find(1);
4 
5$user->subscription()->swap($premium = 'pri_456');

If you would like to swap plans and immediately invoice the user instead of waiting for their next billing cycle, you may use the swapAndInvoice method:

1$user = User::find(1);
2 
3$user->subscription()->swapAndInvoice($premium = 'pri_456');
1$user = User::find(1);
2 
3$user->subscription()->swapAndInvoice($premium = 'pri_456');

Prorations

By default, Paddle prorates charges when swapping between plans. The noProrate method may be used to update the subscriptions without prorating the charges:

1$user->subscription('default')->noProrate()->swap($premium = 'pri_456');
1$user->subscription('default')->noProrate()->swap($premium = 'pri_456');

If you would like to disable proration and invoice customers immediately, you may use the swapAndInvoice method in combination with noProrate:

1$user->subscription('default')->noProrate()->swapAndInvoice($premium = 'pri_456');
1$user->subscription('default')->noProrate()->swapAndInvoice($premium = 'pri_456');

Or, to not bill your customer for a subscription change, you may utilize the doNotBill method:

1$user->subscription('default')->doNotBill()->swap($premium = 'pri_456');
1$user->subscription('default')->doNotBill()->swap($premium = 'pri_456');

For more information on Paddle's proration policies, please consult Paddle's proration documentation.

Subscription Quantity

Sometimes subscriptions are affected by "quantity". For example, a project management application might charge $10 per month per project. To easily increment or decrement your subscription's quantity, use the incrementQuantity and decrementQuantity methods:

 1$user = User::find(1);
 2 
 3$user->subscription()->incrementQuantity();
 4 
 5// Add five to the subscription's current quantity...
 6$user->subscription()->incrementQuantity(5);
 7 
 8$user->subscription()->decrementQuantity();
 9 
10// Subtract five from the subscription's current quantity...
11$user->subscription()->decrementQuantity(5);
 1$user = User::find(1);
 2 
 3$user->subscription()->incrementQuantity();
 4 
 5// Add five to the subscription's current quantity...
 6$user->subscription()->incrementQuantity(5);
 7 
 8$user->subscription()->decrementQuantity();
 9 
10// Subtract five from the subscription's current quantity...
11$user->subscription()->decrementQuantity(5);

Alternatively, you may set a specific quantity using the updateQuantity method:

1$user->subscription()->updateQuantity(10);
1$user->subscription()->updateQuantity(10);

The noProrate method may be used to update the subscription's quantity without prorating the charges:

1$user->subscription()->noProrate()->updateQuantity(10);
1$user->subscription()->noProrate()->updateQuantity(10);

Quantities for Subscriptions With Multiple Products

If your subscription is a subscription with multiple products, you should pass the ID of the price whose quantity you wish to increment or decrement as the second argument to the increment / decrement methods:

1$user->subscription()->incrementQuantity(1, 'price_chat');
1$user->subscription()->incrementQuantity(1, 'price_chat');

Subscriptions With Multiple Products

Subscription with multiple products allow you to assign multiple billing products to a single subscription. For example, imagine you are building a customer service "helpdesk" application that has a base subscription price of $10 per month but offers a live chat add-on product for an additional $15 per month.

When creating subscription checkout sessions, you may specify multiple products for a given subscription by passing an array of prices as the first argument to the subscribe method:

 1use Illuminate\Http\Request;
 2 
 3Route::post('/user/subscribe', function (Request $request) {
 4    $checkout = $request->user()->subscribe([
 5        'price_monthly',
 6        'price_chat',
 7    ]);
 8 
 9    return view('billing', ['checkout' => $checkout]);
10});
 1use Illuminate\Http\Request;
 2 
 3Route::post('/user/subscribe', function (Request $request) {
 4    $checkout = $request->user()->subscribe([
 5        'price_monthly',
 6        'price_chat',
 7    ]);
 8 
 9    return view('billing', ['checkout' => $checkout]);
10});

In the example above, the customer will have two prices attached to their default subscription. Both prices will be charged on their respective billing intervals. If necessary, you may pass an associative array of key / value pairs to indicate a specific quantity for each price:

1$user = User::find(1);
2 
3$checkout = $user->subscribe('default', ['price_monthly', 'price_chat' => 5]);
1$user = User::find(1);
2 
3$checkout = $user->subscribe('default', ['price_monthly', 'price_chat' => 5]);

If you would like to add another price to an existing subscription, you must use the subscription's swap method. When invoking the swap method, you should also include the subscription's current prices and quantities as well:

1$user = User::find(1);
2 
3$user->subscription()->swap(['price_chat', 'price_original' => 2]);
1$user = User::find(1);
2 
3$user->subscription()->swap(['price_chat', 'price_original' => 2]);

The example above will add the new price, but the customer will not be billed for it until their next billing cycle. If you would like to bill the customer immediately you may use the swapAndInvoice method:

1$user->subscription()->swapAndInvoice(['price_chat', 'price_original' => 2]);
1$user->subscription()->swapAndInvoice(['price_chat', 'price_original' => 2]);

You may remove prices from subscriptions using the swap method and omitting the price you want to remove:

1$user->subscription()->swap(['price_original' => 2]);
1$user->subscription()->swap(['price_original' => 2]);

Multiple Subscriptions

Paddle allows your customers to have multiple subscriptions simultaneously. For example, you may run a gym that offers a swimming subscription and a weight-lifting subscription, and each subscription may have different pricing. Of course, customers should be able to subscribe to either or both plans.

When your application creates subscriptions, you may provide the type of the subscription to the subscribe method as the second argument. The type may be any string that represents the type of subscription the user is initiating:

1use Illuminate\Http\Request;
2 
3Route::post('/swimming/subscribe', function (Request $request) {
4    $checkout = $request->user()->subscribe($swimmingMonthly = 'pri_123', 'swimming');
5 
6    return view('billing', ['checkout' => $checkout]);
7});
1use Illuminate\Http\Request;
2 
3Route::post('/swimming/subscribe', function (Request $request) {
4    $checkout = $request->user()->subscribe($swimmingMonthly = 'pri_123', 'swimming');
5 
6    return view('billing', ['checkout' => $checkout]);
7});

In this example, we initiated a monthly swimming subscription for the customer. However, they may want to swap to a yearly subscription at a later time. When adjusting the customer's subscription, we can simply swap the price on the swimming subscription:

1$user->subscription('swimming')->swap($swimmingYearly = 'pri_456');
1$user->subscription('swimming')->swap($swimmingYearly = 'pri_456');

Of course, you may also cancel the subscription entirely:

1$user->subscription('swimming')->cancel();
1$user->subscription('swimming')->cancel();

Pausing Subscriptions

To pause a subscription, call the pause method on the user's subscription:

1$user->subscription()->pause();
1$user->subscription()->pause();

When a subscription is paused, Cashier will automatically set the paused_at column in your database. This column is used to determine when the paused method should begin returning true. For example, if a customer pauses a subscription on March 1st, but the subscription was not scheduled to recur until March 5th, the paused method will continue to return false until March 5th. This is because a user is typically allowed to continue using an application until the end of their billing cycle.

By default, pausing happens at the next billing interval so the customer can use the remainder of the period they paid for. If you want to pause a subscription immediately, you may use the pauseNow method:

1$user->subscription()->pauseNow();
1$user->subscription()->pauseNow();

Using the pauseUntil method, you can pause the subscription until a specific moment in time:

1$user->subscription()->pauseUntil(now()->addMonth());
1$user->subscription()->pauseUntil(now()->addMonth());

Or, you may use the pauseNowUntil method to immediately pause the subscription until a given point in time:

1$user->subscription()->pauseNowUntil(now()->addMonth());
1$user->subscription()->pauseNowUntil(now()->addMonth());

You may determine if a user has paused their subscription but are still on their "grace period" using the onPausedGracePeriod method:

1if ($user->subscription()->onPausedGracePeriod()) {
2    // ...
3}
1if ($user->subscription()->onPausedGracePeriod()) {
2    // ...
3}

To resume a paused subscription, you may invoke the resume method on the subscription:

1$user->subscription()->resume();
1$user->subscription()->resume();

Canceling Subscriptions

To cancel a subscription, call the cancel method on the user's subscription:

1$user->subscription()->cancel();
1$user->subscription()->cancel();

When a subscription is canceled, Cashier will automatically set the ends_at column in your database. This column is used to determine when the subscribed method should begin returning false. For example, if a customer cancels a subscription on March 1st, but the subscription was not scheduled to end until March 5th, the subscribed method will continue to return true until March 5th. This is done because a user is typically allowed to continue using an application until the end of their billing cycle.

You may determine if a user has canceled their subscription but are still on their "grace period" using the onGracePeriod method:

1if ($user->subscription()->onGracePeriod()) {
2    // ...
3}
1if ($user->subscription()->onGracePeriod()) {
2    // ...
3}

If you wish to cancel a subscription immediately, you may call the cancelNow method on the subscription:

1$user->subscription()->cancelNow();
1$user->subscription()->cancelNow();

To stop a subscription on its grace period from canceling, you may invoke the stopCancelation method:

1$user->subscription()->stopCancelation();
1$user->subscription()->stopCancelation();

Subscription Trials

With Payment Method Up Front

If you would like to offer trial periods to your customers while still collecting payment method information up front, you should use set a trial time in the Paddle dashboard on the price your customer is subscribing to. Then, initiate the checkout session as normal:

1use Illuminate\Http\Request;
2 
3Route::get('/user/subscribe', function (Request $request) {
4    $checkout = $request->user()->subscribe('pri_monthly')
5                ->returnTo(route('home'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});
1use Illuminate\Http\Request;
2 
3Route::get('/user/subscribe', function (Request $request) {
4    $checkout = $request->user()->subscribe('pri_monthly')
5                ->returnTo(route('home'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});

When your application receives the subscription_created event, Cashier will set the trial period ending date on the subscription record within your application's database as well as instruct Paddle to not begin billing the customer until after this date.

You may determine if the user is within their trial period using either the onTrial method of the user instance or the onTrial method of the subscription instance. The two examples below are equivalent:

1if ($user->onTrial()) {
2    // ...
3}
4 
5if ($user->subscription()->onTrial()) {
6    // ...
7}
1if ($user->onTrial()) {
2    // ...
3}
4 
5if ($user->subscription()->onTrial()) {
6    // ...
7}

To determine if an existing trial has expired, you may use the hasExpiredTrial methods:

1if ($user->hasExpiredTrial()) {
2    // ...
3}
4 
5if ($user->subscription()->hasExpiredTrial()) {
6    // ...
7}
1if ($user->hasExpiredTrial()) {
2    // ...
3}
4 
5if ($user->subscription()->hasExpiredTrial()) {
6    // ...
7}

To determine if a user is on trial for a specific subscription type, you may provide the type to the onTrial or hasExpiredTrial methods:

1if ($user->onTrial('default')) {
2    // ...
3}
4 
5if ($user->hasExpiredTrial('default')) {
6    // ...
7}
1if ($user->onTrial('default')) {
2    // ...
3}
4 
5if ($user->hasExpiredTrial('default')) {
6    // ...
7}

Without Payment Method Up Front

If you would like to offer trial periods without collecting the user's payment method information up front, you may set the trial_ends_at column on the customer record attached to your user to your desired trial ending date. This is typically done during user registration:

1use App\Models\User;
2 
3$user = User::create([
4    // ...
5]);
6 
7$user->createAsCustomer([
8    'trial_ends_at' => now()->addDays(10)
9]);
1use App\Models\User;
2 
3$user = User::create([
4    // ...
5]);
6 
7$user->createAsCustomer([
8    'trial_ends_at' => now()->addDays(10)
9]);

Cashier refers to this type of trial as a "generic trial", since it is not attached to any existing subscription. The onTrial method on the User instance will return true if the current date is not past the value of trial_ends_at:

1if ($user->onTrial()) {
2    // User is within their trial period...
3}
1if ($user->onTrial()) {
2    // User is within their trial period...
3}

Once you are ready to create an actual subscription for the user, you may use the subscribe method as usual:

1use Illuminate\Http\Request;
2 
3Route::get('/user/subscribe', function (Request $request) {
4    $checkout = $user->subscribe('pri_monthly')
5        ->returnTo(route('home'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});
1use Illuminate\Http\Request;
2 
3Route::get('/user/subscribe', function (Request $request) {
4    $checkout = $user->subscribe('pri_monthly')
5        ->returnTo(route('home'));
6 
7    return view('billing', ['checkout' => $checkout]);
8});

To retrieve the user's trial ending date, you may use the trialEndsAt method. This method will return a Carbon date instance if a user is on a trial or null if they aren't. You may also pass an optional subscription type parameter if you would like to get the trial ending date for a specific subscription other than the default one:

1if ($user->onTrial('default')) {
2    $trialEndsAt = $user->trialEndsAt();
3}
1if ($user->onTrial('default')) {
2    $trialEndsAt = $user->trialEndsAt();
3}

You may use the onGenericTrial method if you wish to know specifically that the user is within their "generic" trial period and has not created an actual subscription yet:

1if ($user->onGenericTrial()) {
2    // User is within their "generic" trial period...
3}
1if ($user->onGenericTrial()) {
2    // User is within their "generic" trial period...
3}

Extend or Activate a Trial

You can extend an existing trial period on a subscription by invoking the extendTrial method and specifying the moment in time that the trial should end:

1$user->subsription()->extendTrial(now()->addDays(5));
1$user->subsription()->extendTrial(now()->addDays(5));

Or, you may immediately activate a subscription by ending its trial by calling the activate method on the subscription: