Mastering Laravel Streamed Responses: Boost Performance with Fast Data Delivery

Sometimes you need to send data to users without making them wait a long time. Laravel’s new streamed response functions make this simple! They let you send stuff bit by bit, like watching a video while it downloads. Let’s check out what’s new: stream(), streamJson(), and eventStream().

#Table of contents

• What’s This All About?
• 1. stream(): Sending Anything in Chunks
  • How It Works
  • Quick Example
  • When to Use It
• 2. streamJson(): JSON Without the Slowdown
  • How It Works
  • Quick Example
  • When to Use It
• 3. eventStream(): Real-Time Updates
  • How It Works
  • Quick Example
  • When to Use It
• Why Bother?
• Wrap-Up

#What’s This All About?

Usually, when your app sends data, it waits until everything’s ready. That can take forever if the data’s big. Streamed responses fix that by sending small pieces as soon as they’re good to go. It’s faster, uses less memory, and feels smooth for users.

#1. stream(): Sending Anything in Chunks

The stream() function is for sending all kinds of data little by little. It’s great for big files or stuff that takes time to make.

#How It Works

You write a function that sends data in parts. Laravel pushes each part out right away if you use ob_flush() and flush().

#Quick Example

Here’s a route that sends “Hello, ” then waits a bit, and sends “World!”:

Route::get('/stream', function () {
    return response()->stream(function () {
        echo 'Hello, ';
        ob_flush();
        flush();
        sleep(2); // Fake some work
        echo 'World!';
        ob_flush();
        flush();
    }, 200, ['X-Accel-Buffering' => 'no']);
});

Hit that route, and you’ll see “Hello, ” first, then “World!” after 2 seconds. It’s a chill way to send stuff without loading everything at once.

Note: Make sure output_buffering is enabled in your PHP settings (e.g., output_buffering = 4096 in php.ini), or you might run into the error: ob_flush(): Failed to flush buffer. No buffer to flush.

#When to Use It

• Big file downloads.
• Data you build step by step, like logs.

#2. streamJson(): JSON Without the Slowdown

If your app sends a lot of JSON—like an API with tons of data—streamJson() is perfect. It sends JSON in pieces so the client gets it fast.

#How It Works

Give it an array or a lazy collection (like cursor() for database stuff), and it streams the JSON without choking your server.

#Quick Example

Here’s how to stream a list of users:

use App\Models\User;
 
Route::get('/users.json', function () {
    return response()->streamJson([
        'users' => User::cursor(), // Grabs users one at a time
    ]);
});

This keeps things quick even with thousands of users.

#When to Use It

• Big JSON responses.
• APIs where you don’t want to load everything in memory.

#3. eventStream(): Real-Time Updates

Want to send live updates, like a chat or notifications? eventStream() uses Server-Sent Events (SSE) to push stuff to the client right when it happens.

#How It Works

You send StreamedEvent objects with event names and data. The client listens with JavaScript, and Laravel closes the stream when you’re done.

#Quick Example

Here’s a chat stream:

use Illuminate\Http\StreamedEvent;
 
Route::get('/chat', function () {
    return response()->eventStream(function () {
        $stream = OpenAI::client()->chat()->createStreamed(...);
        foreach ($stream as $response) {
            yield new StreamedEvent(
                event: 'message',
                data: json_encode($response->choices[0])
            );
        }
    });
});

On the frontend, you’d grab it like this:

const source = new EventSource('/chat');
source.addEventListener('message', (event) => {
    console.log('New message:', event.data);
});

This keeps users updated without them refreshing.

#When to Use It

• Chat apps or live notifications.
• Dashboards with real-time numbers.

#Why Bother?

These streamed responses make your app better:

• Less Memory: No need to hold everything at once.
• Faster: Users get data sooner.
• Live Stuff: Updates happen instantly with eventStream().

It’s all about keeping things smooth and quick.

#Wrap-Up

Laravel’s streamed responses—stream(), streamJson(), and eventStream()—are easy tools to send data smarter. Use stream() for anything chunky, streamJson() for big JSON, and eventStream() for live updates. Pick what fits your project and watch your app speed up!