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 client
  • actionCable() for Rails and AnyCable
  • Custom transports that implement subscribe() or subscribeToChannel()

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 an X-Socket-Id header on same-origin requests, so broadcast(new OrderUpdated($order))->toOthers() won’t trigger a reload for the user who made the change.
  • A cancelable live router event. Return false from 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.