Polling is the classic way to keep a Laravel + Inertia page fresh: call router.reload() every few seconds and hope nothing important changed in between. Inertia.js v3.11 and inertia-laravel v3.7 add a better option called live props. A live prop reloads automatically when a broadcast event arrives, so an order status, a dashboard counter or an activity feed updates the moment the server says so.
The feature has been getting fresh attention in the Laravel community this week, so here is a practical walkthrough: setting up broadcasting, marking props as live, sending values inside the event, throttling and showing a loading state. The official references are the Live Props documentation and the Laravel News release write-up.
How live props work
On the server you wrap a prop with Inertia::live() and tell it which broadcast event should refresh it. Inertia reads the channels from that event’s broadcastOn() method. On the client you give createInertiaApp() a transport (for example Laravel Echo with Reverb). When the event is broadcast, Inertia makes a partial reload for just that prop. If several props listen for the same event on the same channel, they reload together in one request.
Transports included in the release:
echo()for Laravel Echo (Reverb, or Pusher through Echo)pusher()for any Pusher-protocol clientactionCable()for Rails and AnyCable- Custom transports that implement
subscribe()orsubscribeToChannel()
Step 1: Upgrade and set up broadcasting
Upgrade the server and client packages:
composer require inertiajs/inertia-laravel:^3.7
npm install @inertiajs/vue3@^3.11
If your app doesn’t broadcast yet, install broadcasting (this scaffolds the config and lets you pick Reverb):
php artisan install:broadcasting
Then install the Echo package for your front-end framework. The @laravel/echo-vue, @laravel/echo-react and @laravel/echo-svelte packages are optional peer dependencies of Inertia, so only apps that use live props need them:
npm install @laravel/echo-vue
Step 2: Create a broadcast event
A normal Laravel broadcast event works. Here is one for an order:
<?php
namespace App\Events;
use App\Models\Order;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;
class OrderUpdated implements ShouldBroadcast
{
use Dispatchable, InteractsWithSockets, SerializesModels;
public function __construct(public Order $order) {}
public function broadcastOn(): array
{
return [new PrivateChannel('orders.'.$this->order->id)];
}
}
Authorise the private channel in routes/channels.php:
use App\Models\Order;
use Illuminate\Support\Facades\Broadcast;
Broadcast::channel('orders.{order}', function ($user, Order $order) {
return $user->id === $order->user_id;
});
Dispatch it wherever the order changes, for example OrderUpdated::dispatch($order); after a payment webhook.
Step 3: Mark the prop as live
In your controller, wrap the prop with Inertia::live() and pass the event:
use App\Events\OrderUpdated;
use Inertia\Inertia;
public function show(Order $order)
{
return Inertia::render('Orders/Show', [
'order' => Inertia::live(
fn () => $order->fresh(),
on: new OrderUpdated($order),
),
]);
}
The on argument also accepts an array of events, and you can override the channel explicitly:
Inertia::live($value, on: [new OrderUpdated($order), new OrderCancelled($order)]);
Inertia::live($value, on: 'order.updated', channel: new PrivateChannel('orders.1'));
Public, private, presence and encrypted private channels all work.
Combining with other prop types
Deferred, once, optional and always props accept ->live():
'activity' => Inertia::defer(fn () => $order->activity)
->live(on: new ActivityLogged($order)),
One limitation: merge props can’t be live.
Step 4: Configure the client transport
Pass the transport to createInertiaApp(). The echo() helper uses the Echo instance that configureEcho() sets up:
import { createInertiaApp } from '@inertiajs/vue3'
import { echo } from '@inertiajs/vue3/echo'
import { configureEcho } from '@laravel/echo-vue'
configureEcho({ broadcaster: 'reverb' })
createInertiaApp({
live: echo(),
// ...your existing resolve/setup options
})
That’s it. When OrderUpdated is broadcast, the order prop on the open page reloads without any polling code in your component.
Throttling and hidden tabs
Live reloads are throttled to one per prop per second by default. You can change that per prop (milliseconds) or for the whole app:
Inertia::live($value, on: new ActivityLogged, throttle: 4000);
createInertiaApp({
live: echo({ throttle: 2000 }),
})
Reloads also wait while the tab is hidden and run when it becomes visible again. That’s a sensible default for battery and server load. If you really need hidden tabs to update, pass pauseWhenHidden: false to echo().
Skip the reload: send values in the event
By default the event only tells the page “reload this prop”, which costs one HTTP request per open page. If the new value is the same for everyone on the channel, you can put it inside the event with Inertia::broadcastProps() and the page uses it directly:
use App\Http\Resources\OrderResource;
use Inertia\Inertia;
public function broadcastWith(): array
{
return [
...Inertia::broadcastProps([
'order' => OrderResource::make($this->order),
]),
];
}
Be careful here: every subscriber on the channel gets the same payload. Never broadcast per-user data (like permissions or prices that vary by customer) on a shared channel this way. Use the default reload behaviour instead, because the reload runs through your controller with the current user’s authorisation.
Show a loading state with useProp()
The new useProp() hook returns a prop’s value plus loading and loaded flags. loading is true while any request is refreshing the prop, including deferred loads:
<script setup>
import { useProp } from '@inertiajs/vue3'
const { value: order, loading } = useProp('order')
</script>
<template>
<h1>Order #{{ order.id }}</h1>
<span v-if="loading" class="text-sm text-gray-500">Refreshing…</span>
<p>Status: {{ order.status }}</p>
</template>
Useful extras
toOthers()works. Inertia sends the socket ID in anX-Socket-Idheader on same-origin requests, sobroadcast(new OrderUpdated($order))->toOthers()won’t trigger a reload for the user who made the change.- A cancelable
liverouter event. Returnfalsefrom the listener to skip an update, for example while a user is halfway through editing a form on the same page.
When to use live props
Good fits:
- Order, job or deployment status pages
- Admin dashboards and counters
- Comment threads and activity feeds
- Anything you currently poll every few seconds
Less good fits: very high-frequency data (like a live chart updating many times per second), where a dedicated client-side Echo listener that patches local state may be cheaper than repeated partial reloads.
Key takeaways
- Inertia.js 3.11 and inertia-laravel 3.7 add live props:
Inertia::live(fn () => ..., on: new SomeEvent(...)). - Configure a transport once with
createInertiaApp({ live: echo() }). - Reloads are throttled (1/second by default) and pause in hidden tabs.
- Use
Inertia::broadcastProps()only for data that is identical for every subscriber. - Read the full Live Props docs for React and Svelte setup details.
