When your Laravel application works with a small number of database records, retrieving data is usually simple.

For example:

$users = User::all();

But what happens when your users table contains:

• 100,000 records?
• 500,000 records?
• Millions of records?

Loading every record into memory at once can cause serious performance and memory problems.

This is where Laravel chunking and Lazy Collections become useful.

Laravel provides several efficient methods for processing large datasets without loading the entire result into memory:

• chunk()
• chunkById()
• lazy()
• lazyById()
• cursor()

In this guide, you will learn how Laravel chunking and Lazy Collections work, when to use them, their differences, and best practices for processing large amounts of data efficiently.

---

Why Processing Large Datasets Can Be a Problem

Suppose your database contains 1 million users.

You might write:

$users = User::all();

foreach ($users as $user) {
    // Process user
}

The problem is that User::all() retrieves all matching records and loads them into memory.

For a very large dataset, this can lead to:

• High memory usage
• Slow application performance
• PHP memory exhaustion
• Long-running scripts
• Server crashes

The goal is to process data in smaller amounts instead of loading everything at once.

Conceptually:

Bad Approach

1,000,000 Records
        ↓
Load Everything
        ↓
High Memory Usage
        ↓
Process Records

A better approach is:

1,000,000 Records
        ↓
Load Small Batch
        ↓
Process Batch
        ↓
Release Memory
        ↓
Load Next Batch

Laravel’s chunking and lazy methods help achieve this.

---

What Is Laravel Chunking?

Chunking means retrieving database records in smaller groups instead of retrieving the entire dataset at once.

For example, instead of loading 100,000 users:

100,000 Users

You can process them like this:

Batch 1 → 1,000 Users
Batch 2 → 1,000 Users
Batch 3 → 1,000 Users
        ...

Laravel retrieves one chunk, processes it, and then moves to the next chunk.

---

Using chunk() in Laravel

The chunk() method divides query results into smaller collections.

Example:

use App\Models\User;

User::chunk(1000, function ($users) {

    foreach ($users as $user) {
        // Process user
    }
});

In this example:

1. Laravel retrieves 1,000 users.
2. The callback processes those users.
3. Laravel retrieves the next 1,000 users.
4. The process continues until all records are processed.

This is much more memory-efficient than calling User::all() for a large dataset.

---

Understanding the chunk() Flow

The flow looks like this:

Database
    ↓
Fetch 1,000 Records
    ↓
Process Records
    ↓
Fetch Next 1,000 Records
    ↓
Process Records
    ↓
Continue Until Complete

Only one chunk needs to be handled at a time.

---

Example: Sending Notifications in Chunks

Imagine you need to process a large number of users.

User::where('status', 'active')
    ->chunk(500, function ($users) {

        foreach ($users as $user) {

            // Process user
            // Send notification
            // Dispatch a job
        }
    });

Instead of loading every active user into memory, Laravel processes 500 users at a time.

---

Choosing the Right Chunk Size

There is no single perfect chunk size.

Common values include:

100
500
1,000

For example:

User::chunk(500, function ($users) {
    // Process users
});

The best size depends on:

• Available server memory
• Record size
• Complexity of processing
• Database performance
• Application workload

A good approach is to start with a reasonable size and test your application’s performance.

---

The Problem With chunk() When Updating Records

Be careful when updating the same records you are chunking.

For example:

User::where('status', 'pending')
    ->chunk(100, function ($users) {

        foreach ($users as $user) {

            $user->update([
                'status' => 'processed',
            ]);
        }
    });

This can potentially cause problems because the query result changes while records are being processed.

The traditional chunking approach can depend on pagination-style behavior, which may become unreliable when the underlying dataset changes.

For these situations, chunkById() is usually a safer choice.

---

Using chunkById() in Laravel

The chunkById() method processes records based on an increasing ID or another ordered key.

Example:

User::where('status', 'pending')
    ->chunkById(100, function ($users) {

        foreach ($users as $user) {

            $user->update([
                'status' => 'processed',
            ]);
        }
    });

Instead of relying on normal offset-based progression, Laravel continues using the last processed ID.

Conceptually:

First Query
IDs: 1 → 100

Next Query
IDs: Greater than 100

Next Query
IDs: Greater than 200

This makes it better suited for situations where records are being updated during processing.

---

Example: Updating Large Datasets Safely

Suppose you need to update thousands of inactive users.

User::where('last_login_at', '<', now()->subYear())
    ->chunkById(500, function ($users) {

        foreach ($users as $user) {

            $user->update([
                'status' => 'inactive',
            ]);
        }
    });

Because the processing progresses using the ID, changes to other query conditions are less likely to interfere with which records are processed next.

---

What Are Laravel Lazy Collections?

A Lazy Collection allows you to process large datasets while keeping memory usage low.

Instead of loading an entire collection into memory, records are retrieved as they are needed.

Example:

User::lazy()
    ->each(function ($user) {

        // Process one user
    });

Laravel retrieves records in the background and provides them to your code incrementally.

This makes Lazy Collections useful for large datasets and long-running processing tasks.

---

Using lazy() in Laravel

Here is a simple example:

User::lazy()
    ->each(function ($user) {

        // Process user

    });

You can also specify a chunk size:

User::lazy(1000)
    ->each(function ($user) {

        // Process user

    });

Laravel retrieves records in chunks internally, while allowing you to work with the results one item at a time.

The flow looks like this:

Database
    ↓
Internal Batch
    ↓
User 1
User 2
User 3
User 4
    ↓
Next Batch

This can provide a clean syntax while remaining memory efficient.

---

Example: Processing Large Orders With lazy()

Suppose your application has millions of orders.

Order::where('status', 'completed')
    ->lazy()
    ->each(function ($order) {

        // Process order

    });

Each order can be processed individually without loading all completed orders into memory.

---

chunk() vs lazy()

Both methods are useful, but they provide different programming styles.

With chunk():

User::chunk(1000, function ($users) {

    foreach ($users as $user) {
        // Process user
    }
});

You work with an entire batch at once.

With lazy():

User::lazy(1000)
    ->each(function ($user) {
        // Process user
    });

You work with records individually.

Feature	chunk()	lazy()
Processes data in batches	Yes	Internally
Callback receives a collection	Yes	No
Item-by-item processing	Manual loop	Natural
Memory efficient	Yes	Yes
Good for large datasets	Yes	Yes
Supports lazy collection methods	Limited	Yes

Use chunk() when your logic naturally works with batches.

Use lazy() when you prefer processing records one at a time.

---

Using lazyById()

Just like chunkById(), Laravel provides lazyById().

Example:

User::where('status', 'pending')
    ->lazyById(500)
    ->each(function ($user) {

        $user->update([
            'status' => 'processed',
        ]);
    });

This is useful when:

• You are processing a large dataset.
• You want lazy iteration.
• You are modifying records during processing.
• You want to progress using a primary key or ordered ID.

Conceptually:

Last Processed ID
        ↓
Fetch Records With Higher IDs
        ↓
Process One Record at a Time
        ↓
Continue

---

chunkById() vs lazyById()

Both methods are useful when records may change during processing.

chunkById()

User::chunkById(500, function ($users) {

    foreach ($users as $user) {
        // Process user
    }
});

This gives you batches.

lazyById()

User::lazyById(500)
    ->each(function ($user) {

        // Process user
    });

This gives you a lazy, item-by-item interface.

Feature	chunkById()	lazyById()
Processes using ID progression	Yes	Yes
Callback receives batches	Yes	No
Item-by-item processing	Manual	Built in
Suitable while updating records	Yes	Yes
Lazy Collection API	No	Yes

---

What Is cursor() in Laravel?

Laravel also provides the cursor() method.

foreach (User::cursor() as $user) {

    // Process user
}

cursor() returns a Lazy Collection and allows records to be iterated over one at a time.

This can use very little application memory.

It is useful for streaming through large result sets.

---

cursor() vs lazy()

Both are memory-efficient, but they work differently.

With cursor():

foreach (User::cursor() as $user) {

    // Process user
}

With lazy():

User::lazy()
    ->each(function ($user) {

        // Process user

    });

lazy() retrieves records in chunks internally, while cursor() streams results through a database cursor.

For many large-dataset processing tasks, lazy() is convenient because it balances efficient retrieval with Laravel’s Lazy Collection interface.

---

Practical Example: Exporting a Large Dataset

Suppose you need to export thousands of users.

Loading everything at once is not ideal:

$users = User::all();

Instead, use lazy iteration:

$users = User::lazy();

foreach ($users as $user) {

    // Write user data to CSV
}

For example:

$handle = fopen(
    storage_path('app/users.csv'),
    'w'
);

fputcsv($handle, [
    'ID',
    'Name',
    'Email',
]);

User::lazy()
    ->each(function ($user) use ($handle) {

        fputcsv($handle, [
            $user->id,
            $user->name,
            $user->email,
        ]);
    });

fclose($handle);

The users are processed incrementally instead of all being stored in memory.

---

Practical Example: Processing Data With chunk()

Suppose you need to update analytics data in batches.

Order::where('status', 'completed')
    ->chunk(1000, function ($orders) {

        foreach ($orders as $order) {

            // Process analytics data

        }

        // Optional batch-level logic
    });

Chunking is useful here because you can perform operations after processing each batch.

For example:

Process 1,000 Orders
        ↓
Save Batch Result
        ↓
Process Next 1,000 Orders

---

Stopping Chunk Processing Early

You can stop chunking by returning false from the callback.

User::chunk(100, function ($users) {

    foreach ($users as $user) {

        if ($user->id === 500) {
            return false;
        }
    }
});

This can be useful when you find the required result and no longer need to continue processing.

---

Filtering Data Before Chunking

Always try to reduce the dataset before processing it.

For example:

User::where('status', 'active')
    ->whereNotNull('email_verified_at')
    ->chunkById(500, function ($users) {

        foreach ($users as $user) {
            // Process user
        }
    });

This is better than retrieving unnecessary records and filtering them later in PHP.

Let the database perform filtering whenever possible.

---

Select Only Required Columns

If you only need a few columns, do not retrieve every column.

Instead of:

User::lazy()

Use:

User::select(
    'id',
    'name',
    'email'
)
->lazy();

This can reduce:

• Database data transfer
• PHP memory usage
• Query processing overhead

For large datasets, selecting only required columns can make a significant difference.

---

Avoid Heavy Relationships While Processing Large Datasets

Be careful with eager loading large relationships.

For example:

User::with('orders')
    ->lazy();

If every user has many orders, memory usage can increase significantly.

If relationships are required, consider processing them carefully in batches.

For example:

User::with('profile')
    ->chunkById(500, function ($users) {

        foreach ($users as $user) {
            // Process user and profile
        }
    });

The correct approach depends on how much related data each record contains.

---

Use Chunking for Batch Updates

If you need to perform complex processing before updating records, chunking can be useful.

Product::where('status', 'pending')
    ->chunkById(500, function ($products) {

        foreach ($products as $product) {

            $product->update([
                'status' => 'processed',
            ]);
        }
    });

However, if the same update can be performed directly by the database, a single update query is often more efficient.

For example:

Product::where('status', 'pending')
    ->update([
        'status' => 'processed',
    ]);

Do not use chunking when one efficient database query can solve the problem.

---

Chunking and Database Transactions

Be careful when combining very large chunking operations with one long database transaction.

For example:

Start Transaction
        ↓
Process 1,000,000 Records
        ↓
Long-Running Transaction
        ↓
Commit

A long transaction may:

• Hold locks for a long time
• Increase contention
• Increase the chance of deadlocks
• Affect database performance

For large processing tasks, consider smaller transactions when the business logic allows it.

For example:

Chunk 1
   ↓
Transaction
   ↓
Commit

Chunk 2
   ↓
Transaction
   ↓
Commit

Whether this is safe depends on your application’s consistency requirements.

---

Common Mistakes When Processing Large Datasets

1. Using all() for Millions of Records

Avoid:

$users = User::all();

For very large tables, use chunk(), lazy(), or cursor().

---

2. Updating the Same Dataset With Basic chunk()

If the update changes records that affect the original query, prefer:

chunkById()

or:

lazyById()

This provides safer progression through the dataset.

---

3. Choosing an Extremely Large Chunk Size

A chunk size of:

100,000

may defeat the purpose of chunking if each record contains a large amount of data.

Start with a practical size such as:

500

or:

1,000

Then measure performance.

---

4. Selecting Unnecessary Columns

Avoid retrieving every database column when only a few are needed.

Use:

User::select('id', 'email')
    ->lazy();

---

5. Performing Slow External API Calls Inside Database Iteration

For example:

User::lazy()
    ->each(function ($user) {

        // Slow API request

    });

If there are thousands of users, the process may run for a very long time.

For large workloads, consider queues and background jobs.

---

Laravel Chunking Best Practices

When working with large datasets, follow these best practices:

Use chunk() for Batch Processing

User::chunk(1000, function ($users) {
    // Process batch
});

Use chunkById() When Updating Records

User::chunkById(1000, function ($users) {
    // Update records
});

Use lazy() for Item-by-Item Processing

User::lazy()
    ->each(function ($user) {
        // Process user
    });

Use lazyById() for Lazy Processing While Updating

User::lazyById()
    ->each(function ($user) {
        // Process and update
    });

Select Only Required Columns

User::select('id', 'email')
    ->lazy();

Filter Data Before Processing

Let the database reduce the dataset first.

Keep Database Transactions Short

Avoid wrapping an entire million-record process in one transaction unless absolutely necessary.

Use Queues for Very Heavy Workloads

For extremely large tasks, split work into background jobs.

---

Which Laravel Method Should You Use?

Here is a simple guide.

Situation	Recommended Method
Process records in batches	chunk()
Update records while processing	chunkById()
Process records one at a time	lazy()
Update records with lazy iteration	lazyById()
Stream records with minimal memory	cursor()
Simple mass database update	Direct update() query

---

Frequently Asked Questions

What is chunk() in Laravel?

The chunk() method retrieves query results in smaller batches instead of loading the complete result set into memory.

What is lazy() in Laravel?

The lazy() method returns a Lazy Collection that allows large datasets to be processed incrementally and with lower memory usage.

What is the difference between chunk() and lazy()?

chunk() gives you a collection of records for each batch, while lazy() allows you to iterate through records individually while Laravel retrieves them incrementally.

When should I use chunkById()?

Use chunkById() when processing records that may be updated during iteration, especially when changes could affect the original query results.

What is lazyById()?

lazyById() provides lazy iteration while progressing through records using an ID or ordered key, making it useful for large datasets that are modified during processing.

Is cursor() memory efficient?

Yes. cursor() allows records to be iterated over one at a time, helping keep application memory usage low.

What chunk size should I use?

There is no universal value. Common starting points are 100, 500, or 1,000 records. Test your application and adjust based on record size and processing complexity.

---

Conclusion

Processing large datasets efficiently is an important part of building scalable Laravel applications.

Instead of loading thousands or millions of records with:

User::all();

Laravel provides better options:

User::chunk(1000, function ($users) {
    // Process batch
});

Or:

User::lazy()
    ->each(function ($user) {
        // Process one user at a time
    });

The most important thing is choosing the right method for your use case.

• Use chunk() when you need batch processing.
• Use chunkById() when updating records during processing.
• Use lazy() for clean, memory-efficient item-by-item iteration.
• Use lazyById() when records may change during lazy processing.
• Use cursor() when streaming records one at a time is appropriate.

By using Laravel chunking and Lazy Collections correctly, you can process large datasets more efficiently, reduce memory usage, and build applications that scale better as your database grows.