When building a web application, many operations involve multiple database queries. For example, placing an order may require creating an order, updating product stock, processing a payment, and recording a transaction.

But what happens if one query succeeds and another fails?

This is where Laravel database transactions become extremely useful.

Laravel transactions allow you to group multiple database operations into a single unit. Either all operations are completed successfully, or Laravel can roll back the changes to keep your database consistent.

In this guide, you’ll learn what Laravel transactions are, how DB::transaction() works, how to use commit() and rollback(), and the best practices for handling database transactions in Laravel applications.

---

What Is a Database Transaction?

A database transaction is a group of database operations that should be treated as one complete operation.

Imagine a banking application where you transfer money from one account to another.

The process might involve:

1. Deducting money from Account A
2. Adding money to Account B
3. Creating a transaction history record

All of these operations should succeed together.

If money is deducted from Account A but adding money to Account B fails, your application could leave the database in an inconsistent state.

A transaction prevents this problem.

Important: A transaction follows an all-or-nothing approach. If every operation succeeds, the transaction is committed. If something fails, the changes can be rolled back.

---

Why Use Laravel Database Transactions?

Laravel database transactions help maintain data integrity and consistency when multiple database operations depend on each other.

They are especially useful for:

• Order placement
• Payment processing
• Bank transfers
• Inventory updates
• Wallet transactions
• User registration with multiple records
• Booking systems
• E-commerce applications

For example, when a customer places an order, you may need to:

• Create the order
• Create order items
• Reduce product inventory
• Record the payment

These operations are connected. If one fails, you usually do not want the other changes to remain in the database.

---

How Laravel Transactions Work

Laravel provides the DB facade for working with database transactions.

There are two common approaches:

1. Using DB::transaction()
2. Using beginTransaction(), commit(), and rollBack()

Let’s look at both approaches.

---

Using DB::transaction()

The easiest and most commonly used method is DB::transaction().

use Illuminate\Support\Facades\DB;

DB::transaction(function () {

    // Database operations

});

Laravel automatically starts a transaction before running the callback.

If all queries execute successfully, Laravel automatically commits the transaction.

If an exception occurs, Laravel automatically rolls back the transaction.

Example

use App\Models\Order;
use App\Models\Product;
use Illuminate\Support\Facades\DB;

DB::transaction(function () {

    $order = Order::create([
        'user_id' => auth()->id(),
        'total' => 1500,
    ]);

    $product = Product::findOrFail(1);

    $product->decrement('stock', 1);
});

If both operations succeed, the transaction is committed.

If an exception occurs while updating the product, Laravel rolls back the order creation as well.

This makes DB::transaction() a clean and safe option for most Laravel applications.

---

Laravel Transaction Example: Creating an Order

Let’s consider a more practical example.

Suppose a user purchases multiple products from an e-commerce website.

The application needs to:

1. Create an order
2. Create order items
3. Update product stock

We can wrap all of these operations inside a Laravel transaction.

use App\Models\Order;
use App\Models\OrderItem;
use App\Models\Product;
use Illuminate\Support\Facades\DB;

DB::transaction(function () use ($cartItems) {

    $order = Order::create([
        'user_id' => auth()->id(),
        'status' => 'pending',
        'total' => 2500,
    ]);

    foreach ($cartItems as $item) {

        $product = Product::findOrFail($item['product_id']);

        if ($product->stock < $item['quantity']) {
            throw new Exception('Insufficient product stock.');
        }

        OrderItem::create([
            'order_id' => $order->id,
            'product_id' => $product->id,
            'quantity' => $item['quantity'],
            'price' => $product->price,
        ]);

        $product->decrement('stock', $item['quantity']);
    }
});

If any product has insufficient stock, an exception is thrown.

Laravel then rolls back the entire transaction.

As a result:

• The order is not saved
• Order items are not saved
• Product stock is not changed

This keeps the database consistent.

---

Manual Laravel Transactions

Sometimes you need more control over your transaction.

Laravel allows you to manually start, commit, and roll back a transaction.

use Illuminate\Support\Facades\DB;

DB::beginTransaction();

try {

    // Database operations

    DB::commit();

} catch (\Exception $e) {

    DB::rollBack();

    throw $e;
}

Here is how each method works:

Method	Purpose
DB::beginTransaction()	Starts a database transaction
DB::commit()	Permanently saves all changes
DB::rollBack()	Reverts changes made during the transaction

---

Manual Transaction Example

use App\Models\User;
use App\Models\Profile;
use Illuminate\Support\Facades\DB;

DB::beginTransaction();

try {

    $user = User::create([
        'name' => 'John Doe',
        'email' => 'john@example.com',
        'password' => bcrypt('password'),
    ]);

    Profile::create([
        'user_id' => $user->id,
        'bio' => 'New user profile',
    ]);

    DB::commit();

} catch (\Throwable $e) {

    DB::rollBack();

    throw $e;
}

If both the user and profile are created successfully, Laravel commits the transaction.

If profile creation fails, the user record is also rolled back.

---

What Is Commit in Laravel?

A commit permanently saves all successful database changes made during a transaction.

DB::commit();

For example:

DB::beginTransaction();

try {

    // Create user
    // Create profile

    DB::commit();

} catch (\Exception $e) {

    DB::rollBack();
}

After commit() is executed, the changes become permanent in the database.

You cannot use rollBack() afterward to undo the committed transaction.

---

What Is Rollback in Laravel?

A rollback cancels the changes made during the current transaction.

DB::rollBack();

Suppose your application performs three operations:

Create Order       ✓
Update Stock       ✓
Process Payment    ✗

Without a transaction, the first two operations may remain in the database.

With a transaction, you can roll everything back:

Create Order       ↩ Rolled Back
Update Stock       ↩ Rolled Back
Process Payment    Failed

This helps protect your application from incomplete operations.

---

Laravel Transactions with Exception Handling

Exception handling is extremely important when working with manual transactions.

A recommended structure is:

DB::beginTransaction();

try {

    // Your database operations

    DB::commit();

} catch (\Throwable $e) {

    DB::rollBack();

    // Log or handle the exception

    throw $e;
}

Using Throwable can catch both exceptions and other PHP errors that are throwable.

You can also log the error:

use Illuminate\Support\Facades\Log;

DB::beginTransaction();

try {

    // Database operations

    DB::commit();

} catch (\Throwable $e) {

    DB::rollBack();

    Log::error('Transaction failed', [
        'message' => $e->getMessage(),
    ]);

    throw $e;
}

---

Nested Transactions in Laravel

Sometimes a transaction may call another method that also uses a transaction.

Laravel supports nested transaction handling.

DB::transaction(function () {

    // First operation

    DB::transaction(function () {

        // Nested operation

    });
});

However, nested transactions should be used carefully.

Depending on the database driver, Laravel may use mechanisms such as savepoints to manage nested transaction behavior.

For most applications, it is better to keep transaction logic clear and avoid unnecessarily deep transaction nesting.

---

Laravel Transactions and Eloquent

Laravel transactions work perfectly with Eloquent models.

You can use:

User::create();

$order->save();

$product->update();

Product::where('id', 1)->decrement('stock');

All of these database operations can be placed inside a transaction.

Example:

DB::transaction(function () {

    $user = User::create([
        'name' => 'John Doe',
        'email' => 'john@example.com',
    ]);

    $user->profile()->create([
        'bio' => 'Laravel Developer',
    ]);
});

If profile creation fails with an exception, the user creation can also be rolled back.

---

Handling Deadlocks with Laravel Transactions

In applications with high database activity, deadlocks can sometimes occur.

For example, two transactions may try to update the same records in a conflicting order.

Laravel allows you to specify the number of retry attempts:

DB::transaction(function () {

    // Database operations

}, 5);

In this example, Laravel can retry the transaction up to five times when a deadlock occurs.

This can be useful for high-traffic applications where concurrent database operations are common.

---

Best Practices for Laravel Database Transactions

1. Keep Transactions Short

Do not keep a transaction open longer than necessary.

Avoid performing slow operations such as:

• Sending emails
• Calling external APIs
• Uploading files
• Long calculations

inside a database transaction whenever possible.

A better approach is to complete the database work first and then perform other tasks.

---

2. Only Wrap Related Database Operations

Do not place every query in your application inside a transaction.

Use transactions when multiple operations depend on each other.

For example:

Create Order
↓
Create Order Items
↓
Update Inventory

These operations are strongly connected and are good candidates for a transaction.

---

3. Use DB::transaction() When Possible

For simple use cases, prefer:

DB::transaction(function () {

    // Database operations

});

It is cleaner and Laravel automatically handles committing and rolling back when exceptions occur.

Use manual transactions when you specifically need additional control.

---

4. Validate Data Before Starting the Transaction

Whenever possible, validate user input before opening a transaction.

$request->validate([
    'name' => 'required|string',
    'email' => 'required|email',
]);

Then start the database transaction.

This helps keep transactions shorter and reduces unnecessary database locking.

---

5. Do Not Silently Ignore Exceptions

Avoid code that rolls back a transaction but hides the actual problem.

Always log, report, or properly handle important exceptions.

catch (\Throwable $e) {

    DB::rollBack();

    report($e);

    throw $e;
}

---

Common Laravel Transaction Mistakes

Forgetting to Roll Back

With manual transactions, always ensure failures result in a rollback.

catch (\Throwable $e) {

    DB::rollBack();

    throw $e;
}

Performing External API Calls Inside a Transaction

External services may be slow or fail independently.

Try to avoid this:

DB::transaction(function () {

    // Save order

    // Call payment API
});

Keep database transactions focused on database consistency.

Catching Exceptions Inside DB::transaction() Without Re-Throwing

Be careful with this pattern:

DB::transaction(function () {

    try {

        // Database operation

    } catch (\Exception $e) {

        // Error is ignored
    }
});

If you catch an exception and do not re-throw it, Laravel may not know that the transaction should fail.

A safer approach is:

DB::transaction(function () {

    try {

        // Database operation

    } catch (\Throwable $e) {

        throw $e;
    }
});

---

DB::transaction() vs Manual Transactions

Here is a quick comparison:

Feature	DB::transaction()	Manual Transaction
Easy to use	Yes	Moderate
Automatic rollback on exception	Yes	No, you handle it
Automatic commit	Yes	No, you handle it
Best for simple workflows	Yes	Yes
Maximum control	Limited	High

For most use cases, DB::transaction() is the preferred option because it keeps the code clean and reduces the chance of forgetting to commit or roll back.

---

Frequently Asked Questions

What is a transaction in Laravel?

A Laravel transaction groups multiple database operations together. If all operations succeed, the changes are committed. If an error occurs, the transaction can roll back the changes.

What does DB::transaction() do?

DB::transaction() executes database operations inside a transaction. Laravel automatically commits successful operations and rolls back the transaction when an exception occurs.

What is the difference between commit and rollback?

commit() permanently saves transaction changes, while rollBack() cancels changes made during the current transaction.

Can I use Eloquent inside a Laravel transaction?

Yes. Eloquent methods such as create(), update(), save(), and relationship operations can be used inside Laravel database transactions.

When should I use a database transaction?

Use a transaction when multiple database operations must either all succeed or all fail, such as order creation, payments, inventory updates, and financial transactions.

---

Conclusion

Laravel database transactions are essential when your application performs multiple related database operations.

By using Laravel transactions, you can prevent partial updates and keep your application data consistent. The simplest approach is usually DB::transaction(), while beginTransaction(), commit(), and rollBack() give you more control when needed.

The key principle is simple:

If several database operations depend on each other, consider wrapping them in a transaction.

By keeping transactions short, handling exceptions properly, and only grouping related database operations, you can build more reliable, secure, and maintainable Laravel applications.