DEV Community: Arunas Skirius

How to Sell API Credits in Laravel

Arunas Skirius — Fri, 24 Jan 2025 15:12:24 +0000

In today's API economy, choosing the right monetization strategy can make or break your business. While subscription-based pricing remains popular, many companies are discovering the advantages of selling API credits – a flexible approach that lets customers prepay for usage and consume services at their own pace.

Think of API credits as a digital currency specific to your service. Instead of charging customers based on calendar months or user seats, you let them purchase credits upfront and deduct them based on API calls or specific actions. Companies like OpenAI and Google Cloud have popularized this model, but it's equally effective for businesses of any size.

In this guide, we'll explore why credit-based pricing might be the right choice for your API business and walk through a practical implementation using Laravel and Stripe. You'll learn how to set up the entire system – from selling credit packages to tracking usage in your application.

👉 Read the original article here 👈

// Detect dark theme var iframe = document.getElementById('tweet-1882807378124702083-192'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1882807378124702083&theme=dark" }

How to build a SaaS in a weekend

Arunas Skirius — Fri, 24 Nov 2023 08:37:55 +0000

You might think the development of the software is the difficult part, but I’m here to put that in perspective. There are tons of templates and tools to automate a lot of the development of a standard SaaS (Software as a Service), which allows you to skip (or speed-through) a lot of steps and still deliver a quality product for your customers. Using existing tools will allow you time to focus on building out the business logic, the part that separates you from your competition, and iterate faster, testing new ideas and getting to profitability much quicker. Last but not least, you will have time to do marketing!

As a proof of concept, I have built a fully-functional SaaS in a single weekend, and in this article I am going to show you how. Feel free to copy everything you see here and create a SaaS of your own. Let’s begin.

What does a SaaS need?

First, let’s address what we need to achieve in terms of product. Customers of your SaaS have certain expectations, and if you don’t address some of them - you might not have a usable product. Here’s what a typical SaaS needs to get started:

Business logic - first and foremost, you need a feature to sell - whether it’s API access, an automation, report generation, a fully-fledged platform for agencies, or some other feature that provides value to your customer.
Authentication - ability to sign up, log in, reset password, perhaps even two-factor authentication for extra security.
Billing - ability to enter payment details, charge money, and create/display invoices.
Documentation - your customers need to know how to use your product. Even the most well-thought software needs a help center or API documentation for your customers to get unstuck and get the most value from your product.
Landing page - your customers need a place to get a first impression and learn about your product before signing up. You will share this page across all of your marketing efforts later.
Hosting - finally, your business needs to be available to the public. Once you’re done building it locally, let’s put it to the cloud!

I think the above list is a great starting point for a SaaS, and will be perfectly usable for your customers, and all of the above can be built or set up in a single weekend!

Continue reading on arunas.dev

Log Viewer v3 is out

Arunas Skirius — Mon, 28 Aug 2023 11:46:43 +0000

Log Viewer v3 brings several quality of life features that I'm sure you will enjoy - different log format support, and email previews.

Support for multiple log formats

Log Viewer can now view not just Laravel logs, but also Apache, Nginx, Redis, Postgres, Supervisor, and more. Here you can see the types of logs that are now supported by Log Viewer out of the box.

Showing these logs in the new Log Viewer is as easy as adding the paths to your logs in the config/log-viewer.php configuration, like so:

    /*
    |---------------------------------------------------------
    | Include file patterns
    |---------------------------------------------------------
    |
    */

    'include_files' => [
        '*.log',
        '**/*.log',

        // You can include paths to other log types as well, such as apache, nginx, and more.
        '/var/log/httpd/*',
        '/var/log/nginx/*',

        // For example, logs can be found on MacOS Apple Silicon machines
        '/opt/homebrew/var/log/nginx/*',
        '/opt/homebrew/var/log/httpd/*',
        '/opt/homebrew/var/log/php-fpm.log',
        '/opt/homebrew/var/log/postgres*log',
        '/opt/homebrew/var/log/redis*log',
        '/opt/homebrew/var/log/supervisor*log',

        // '/absolute/paths/supported',
    ],

If you don't see a particular log format, don't worry - you can now define custom log formats which will allow you to browse these custom logs within the Log Viewer UI that you love. Defining custom logs also works for overriding the existing, built-in log formats. If, for example, your Laravel or HTTP logs are somehow different from factory defaults, you can extend the parser classes to include the custom modifications you've made. You can read all about extending log formats here.

Log type switcher

Supporting multiple types of logs means there a lot more... logs... To help find exactly what you're looking for, or to focus your search on particular log types, we have added a log type selector. The selector will show up as soon as Log Viewer finds more than one type of log.

Email previews

How often do you use the log mail driver? I know I don't, simply because it's very difficult to read these raw emails with headers and MIME parts, much less see how they actually look. I've always opted in for other solutions like Mailtrap, Helo, or just sending real emails.

Well, all the other tools require additional setup, separate apps, or can be plain dangerous in test environments (ever sent a test email to a real person by mistake?)

The log mail driver is the simplest, and safest approach to sending emails locally. It becomes even more useful with Log Viewer v3, which brings email previews directly within the Log Viewer:

All you need to make this work is to set this in your .env:

MAIL_MAILER=log

The emails you send will instead be logged to your Laravel log, and they will then be viewable within the Log Viewer. Nifty little feature, don't you think? :)

Upgrading

Log Viewer v3 is an easy upgrade without any breaking changes for most users. You can learn how to upgrade from v2 to v3 here. The documentation has been updated for Log Viewer v3.

Questions / Feedback

If you have any questions, issues, bugs to report - please send them directly to the project's GitHub page - issues or discussions.

Support

If you enjoy using this free, open-source project, there's several ways you can give back:

Submit a PR - fix a bug, add a new feature, refactor code. All PRs are welcome.
Add support for additional log formats - there's tons of different log formats in the world, and the more we can support in the Log Viewer - the better. Submit a PR with a new format support.
Buy me a coffee! ☕️ I'm an avid coffee drinker, which helps me work through the weekends after my full-time job to provide you with the Log Viewer for free :)

How to automate Stripe invoice emailing Laravel

Arunas Skirius — Mon, 12 Jun 2023 06:00:47 +0000

In this blog post, we will guide you through automating the process of generating and emailing invoices with Laravel, specifically using the Laravel Cashier package. By the end of this post, you'll be able to automatically generate professional-looking invoices, customized to your needs, and have them automatically emailed to your customers.

Prerequisites

Before we dive into the main content, it's important to ensure you have the following prerequisites in place.

Laravel Setup: You should have a Laravel application up and running. Laravel is a powerful PHP framework that simplifies the process of building complex web applications. Learn how to get started with Laravel.
Laravel Cashier: Laravel Cashier provides an expressive, fluent interface to Stripe's subscription billing services. It handles almost all of the boilerplate subscription billing code you are dreading writing. You should have it installed and configured with your Stripe account. Learn how to set up Cashier.
Subscriptions: You should have your subscription models set up in Laravel. If you haven't done that, you can refer to our previous guide on How to set up recurring payments in Laravel which will guide you step-by-step on setting up subscriptions using Laravel and Cashier.
Email Provider: Lastly, you should have access to an email provider for sending emails. In this guide, we will discuss some common email providers such as Mailgun and Sendgrid, which offer free tiers for small businesses or startups.

Once you have these prerequisites in place, you are ready to automate the process of invoice generation and emailing in your Laravel application. Let's begin.

Previewing the invoice

This will only be used for us to test and to see what the final invoice looks like as a PDF. It is a great way to quickly iterate and make changes to the invoice before we start automating the process.

Set up a new subscription

This article assumes you have already have a subscription for your user. If not, here's a quick reminder of how you would do that. After setting up Laravel Cashier, creating a new subscription for a user is quite straightforward. Here is an example:

$user = User::find(1);
$user->newSubscription('default', 'premium')->create($creditCardToken);

In the above example, we find the user and create a new subscription for them. The 'default' in the newSubscription() function is the name of the subscription, and 'premium' is the specific Stripe plan's ID to which the user is subscribing. The $creditCardToken variable is obtained when collecting the user's payment method in the frontend with Stripe's tools. Read more about setting up subscriptions for users here.

Preview the invoice

Now that we've created a subscription, we can generate an invoice for it. We'll create an HTTP route that fetches the first invoice and downloads it as a PDF.

Open your web.php file located at routes/web.php and add the following route:

use Illuminate\Support\Facades\Route;
use Illuminate\Support\Facades\Auth;
use Symfony\Component\HttpFoundation\Response;

Route::get('/invoice/preview', function () {
    $user = Auth::user(); // fetch the authenticated user

    $invoice = $user->invoices()->first(); // get the first invoice

    if ($invoice) {
        return $invoice->download([
            'vendor' => 'Your Company',
            'product' => 'Your Product',
            'street' => 'Main Str. 1',
            'location' => '2000 Antwerp, Belgium',
            'phone' => '+32 499 00 00 00',
            'email' => 'info@example.com',
            'url' => 'https://example.com',
            'vendorVat' => 'BE123456789',
        ]);
    }

    return new Response('No invoice found', 404);
});

In the above route, we're authenticating the user, fetching their first invoice, and using the downloadInvoice() method to generate and download the invoice as a PDF.

You can now preview the invoice by navigating to http://localhost/invoice/preview in your browser.

You should now see a generated PDF of a subscription invoice. In the next section, we'll delve into how you can automate the process of emailing them to your users.

Automating emailing of invoices

Having set up and customized our invoices, the next step is to automate the process of sending these invoices via email to our users. We can tap into webhooks to automatically react to new invoices and send them to your customers via email whenever they are created.

Read the rest of the article here

How to delay Laravel jobs and listeners within database transactions

Arunas Skirius — Thu, 30 Mar 2023 07:07:10 +0000

As a Laravel developer, you may have encountered issues with jobs and listeners fired within database transactions. These issues can lead to ModelNotFoundException, inconsistencies in your data, and other problems that can affect the reliability of your application. In this blog post, we will explore why database transactions are important, common issues that can arise when using them, and how to properly handle jobs and listeners within transactions.

Why use database transactions?

Database transactions allow you to group multiple database operations into a single atomic unit. If any part of the transaction fails, all changes are rolled back, ensuring that your database remains in a consistent state. In Laravel, you can use transactions to execute multiple database queries within a single transaction by using the DB::transaction method. Here's an example:

use Illuminate\Support\DB;

DB::transaction(function () {
    // Perform database queries here
});

Alternatively, to have more control you can also use a non-callback method of controlling database transactions:

use Illuminate\Support\Facades\DB;

DB::beginTransaction();

try {
    // Perform database operations here
    DB::commit();
} catch (\Exception $e) {
    DB::rollback();
    // Handle the exception here
}

But for the sake of this article, we will stick to the first option - using callbacks.

Common issues with database transactions

While database transactions are crucial for maintaining data consistency in Laravel, there are some common issues that developers may encounter when using them, particularly with jobs and listeners. In this section, we will discuss these issues in more detail.

ModelNotFoundException in queued jobs

Jobs firing with models that have never been saved because of rollbacks, a.k.a. ModelNotFoundException in jobs.

Consider a scenario where you use a job to create a new user and add some records to the database. However, if the transaction rolls back due to an error, the job may be dispatched with incomplete or non-existent data. This can cause the ModelNotFoundException exception to be thrown, as the job will attempt to access a model that has never been saved. This can be particularly problematic if the job is responsible for sending important notifications or performing other critical actions.

Event listeners performing actions that cannot be rolled back

Suppose you have a listener that performs an external API call to sync data with a third-party service. If the transaction is rolled back, this action cannot be undone, leading to data inconsistencies between your application and the external service. This can cause significant problems, especially if the external service is business-critical.

The solutions

Laravel has great and easy solutions for both problems to ensure that the jobs, or listeners, are not executed until after the database transaction is committed.

Let's have a look!

Dispatching a Laravel job after a transaction is committed

To ensure that jobs are only dispatched after the transaction has been committed, you can use the afterCommit method. This method will only dispatch the job after the transaction has been committed successfully. Here's an example:

DB::transaction(function () use ($data) {
    // Perform database queries here

    dispatch(new MyJob($data))->afterCommit();

    // alternatively, if the job uses the Dispatchable trait:
    // MyJob::dispatch($data)->afterCommit();

    // Perform other operations that could potentially fail
    // and roll back the transaction.
});

Alternatively, for more control, you can also use a DB::afterCommit() method to provide a callback that will run after the transaction is committed:

DB::transaction(function () use ($data) {
    // Perform database queries here

    DB::afterCommit(function () {
        dispatch(new MyJob($data));
    });

    // Perform other operations that could potentially fail
    // and roll back the transaction.
});

Delaying a Laravel event listener to run after a transaction is committed

To ensure that listeners are only executed after the transaction has been committed, you can set the $afterCommit property on your listener. This method will delay the execution of the listener until the transaction has been committed successfully. Here's an example:

class SendNotificationListener
{
    public $afterCommit = true;

    public function handle(MyEvent $event)
    {
        // Send notification email here
    }
}

It does not matter whether the listener is synchronous or asynchronous (queued, implementing ShouldQueue interface) - Laravel will only execute this event after the database transaction is committed.

Very convenient!

Handling jobs and listeners within database transactions requires careful consideration to ensure that your application's data remains consistent. By using the afterCommit method to dispatch jobs later, and the $afterCommit = true property on listeners to delay them until after the transaction has been committed, you can avoid common issues such as ModelNotFoundException and external API calls that cannot be rolled back. Using these methods you can ensure that your Laravel application operates reliably and consistently.

Hope you learned something new today!

What is complexity? Write Better Laravel

Arunas Skirius — Fri, 08 Jul 2022 13:40:27 +0000

“Write Better Laravel” is a new blog series about designing sustainable, clean code.

In order to write better code, we first must understand our enemy.

What is “complexity”?
How can you tell if the system is unnecessarily complex?
What causes the system to become complex?

Once you understand complexity and how to spot it, you will start writing better code that is simpler to understand, use, extend and maintain.

Complexity is anything related to the structure of a software system that makes it hard to understand and modify the system.

Click here to read the rest of the article...

🚀 Spike billing has LAUNCHED!

Arunas Skirius — Tue, 05 Jul 2022 16:28:32 +0000

Just wanted to announce that Spike billing - a Laravel package to bootstrap your project with automatic subscription billing - has now launched! 🎉🎉🎉

Spike makes it easy to charge subscriptions and one-off purchases in your Laravel app.

It comes with credit management solution out of the box, so that your users/teams can purchase credits to spend on using your app - it's perfect for paid APIs.

Users get a beautiful billing portal where they can see the available purchases/subscriptions, manage their payment methods, see their invoices, and also view their activity and credit usage - tons of great stuff.

You will save hundreds of hours of development time and be able to launch your project much faster.

There are a few early bird licenses available, so hurry before they're gone.

Hope you like the project, and do let me know if you have any questions or feedback.

Thanks! 🙌

How to use Laravel Facades safely

Arunas Skirius — Mon, 13 Jun 2022 08:17:43 +0000

It's not exactly clear in the Laravel documentation, but there's one thing the Facades do that might introduce accidental bugs in your system:

Facades are like singletons.

Unlike traditional service container bindings with anonymous functions, Facades retain the resolved instance and use that in future Facade calls.

In this article I explain why this is happening, and offer a couple solutions to prevent this bug in your code.

Let me know what you think!

Developer-friendly Landing Pages

Arunas Skirius — Tue, 07 Jun 2022 11:11:00 +0000

I don't like page builders.

As an "experienced" developer, I like having control over my websites. Being able to see, edit and publish any fine-tuned changes in HTML, CSS, JavaScript and all of the backend logic.

That is not something many of the "Landing Page builders" can give or promise. They are often filled with unnecessary bloat, making for a worse experience for the visitor.

They also cost a ton. 😵‍💫

I went on to build the landing page myself from scratch, using some of the easiest and fastest frameworks available today.

Ok, then what?

Build the pages yourself with Next.js/Nuxt.js + some CSS framework + Vercel/Netlify.

Since I have experience with Vue.js + Tailwind, I chose the tools geared for that. You might choose different ones if you're into React, Angular or Svelte, but the point is - it's there, it's free, and really easy to use.

By building these landing pages yourself, instead of using page builders - you:

retain full control of the website. Make any changes at any time, no matter how complex they are
don't have to pay hefty fees for the page builders
the website is much much faster
you get to write more code (isn't that the fun part??)

Read more about my experience of building a fast and beautiful landing page in just a few hours here:

https://arunas.dev/developer-friendly-landing-pages/

Hope this inspires some more of you to ditch the builders and make it your own! 😄 I mean, I know I'm in the right space, cos we're developers after all!

Thanks everyone 🙌