Ehsan Bagherzadegan
Back to articles
6 min read

Inertia.js v3.11 Live Props: Real-Time Updates Without Polling

Inertia.js v3.11 introduces live props — server-declared props that automatically refresh via Laravel broadcasting when an event fires, eliminating polling and manual WebSocket glue code.

Inertia.js v3.11 shipped on November 2, 2026, and its headline feature — live props — changes how you build real-time interfaces in Inertia applications. Instead of polling or manually wiring up WebSocket listeners, you mark a prop as "live" on the server and Inertia handles the rest: it subscribes to the relevant broadcast channel, listens for the event, and refreshes the prop automatically.

This is a practical improvement for any Laravel team using Inertia with Vue, React, or Svelte. Here is how it works, what it replaces, and where the edges are.

The problem live props solve

Before v3.11, real-time updates in Inertia meant one of three approaches:

  1. Polling — setInterval calling router.reload() or router.visit(). Simple but wasteful; you either poll too often and hammer the server, or not often enough and the UI feels stale.
  2. Manual Echo/Pusher listeners — Subscribe in onBeforeMount, call router.reload({ only: ['order'] }) when an event arrives. Works, but boilerplate grows with every live component.
  3. Laravel Reverb + custom glue — Full control, but you are building plumbing instead of features.

Live props collapse this into a declarative pattern: the server says what should update and when, the client handles how.

Server side: marking a prop as live

In your controller or route closure, wrap the value with Inertia::live() and pass the broadcast event that should trigger a refresh:

use App\Events\OrderUpdated;
use Inertia\Inertia;

return Inertia::render('Orders/Show', [
    'order' => Inertia::live(
        fn () => $order->fresh(),
        on: new OrderUpdated($order)
    ),
]);

The closure is evaluated only when the event fires, not on the initial render. The on argument accepts a single event instance, an array of events, or a custom channel:

// Multiple events, same prop
'on' => [
    new OrderUpdated($order),
    new OrderCancelled($order),
]

// Custom channel (bypasses event's broadcastOn)
'channel' => new PrivateChannel("orders.{$order->id}"),

Inertia reads the channel(s) from the event's broadcastOn() method. Your event must implement ShouldBroadcast and use the InteractsWithSockets trait — standard Laravel broadcasting.

Client side: enabling the transport

In your app's entry point, pass a transport to createInertiaApp(). The @inertiajs/vue3/echo package (also available for React and Svelte) provides the echo() helper:

// resources/js/app.js
import { createInertiaApp } from '@inertiajs/vue3'
import { echo } from '@inertiajs/vue3/echo'
import { configureEcho } from '@laravel/echo-vue'

configureEcho({ broadcaster: 'reverb' })

createInertiaApp({
    resolve: name => import(`./Pages/${name}.vue`),
    setup({ el, App, props, plugin }) {
        createApp({ render: () => h(App, props) })
            .use(plugin)
            .mount(el)
    },
    live: echo(),
})

Transports for Pusher (pusher()), Action Cable (actionCable()), and a low-level subscribe() / subscribeToChannel() API are also available if you are not on Reverb.

What happens when the event fires

  1. Inertia receives the broadcast event on the channel.
  2. It finds all live props registered for that event + channel combination.
  3. It issues a partial reload (XHR/Fetch) for those props only — only[] query parameters, same as router.reload({ only: ['order'] }).
  4. The server re-evaluates the closures for those props and returns fresh JSON.
  5. The client merges the new prop values into the page component.

Props that share the same event and channel are batched into a single request.

Broadcasting values directly (zero-request updates)

If the data is identical for every subscriber — a global notification counter, a site-wide banner — you can skip the reload entirely by sending the new value in the event payload:

// App\Events\OrderUpdated.php
use Inertia\Inertia;

public function broadcastWith(): array
{
    return [
        ...Inertia::broadcastProps([
            'order' => OrderResource::make($this->order),
        ]),
    ];
}

On the client, the prop updates instantly without a network round-trip. Only use this when the value is the same for every user on the channel. Private per-user data must go through the reload path.

Throttling and hidden-tab behavior

By default, Inertia throttles reloads to one per second per prop. Configure it per-prop or globally:

// Per-prop
Inertia::live(fn () => $order->fresh(), on: new OrderUpdated($order))
    ->throttle(500) // milliseconds

// Global (in createInertiaApp)
live: echo({ throttle: 2000 })

When the browser tab is hidden, reloads pause and resume when the tab becomes visible again. This saves battery and server load. Disable with pauseWhenHidden: false on the transport or per-prop.

Loading state with useProp()

The new useProp() composable (Vue) / hook (React) gives you reactive access to the prop's value and its loading state:



loading is true during the partial reload; loaded becomes true after the first successful load (useful for initial hydration checks).

When to use live props (and when not to)

Good fits:

  • Order status pages, dashboards, notifications, collaborative editing indicators — any server-driven data that changes sporadically and should reflect instantly.
  • Replacing existing polling or manual Echo listeners with less code.

Not a fit:

  • High-frequency updates (stock tickers, live chat messages) — the HTTP reload overhead adds up. Use a dedicated WebSocket channel and client-side state for those.
  • Data that requires optimistic UI — live props are pull-based (reload on event), not push-based. For optimistic updates, keep your own Echo listener and mutate local state first.
  • Public data that differs per user — broadcastProps sends the same payload to everyone; use the reload path for personalized data.

Migration notes

  • Live props require Inertia.js v3.11 on both server (inertiajs/inertia-laravel) and client (@inertiajs/vue3, @inertiajs/react, or @inertiajs/svelte).
  • The @inertiajs/vue3/echo package is new — add it to package.json and update your entry point as shown above.
  • Existing ShouldBroadcast events work unchanged; just pass them to Inertia::live().
  • If you use a custom Echo connector, ensure it exposes the same listen/listenForWhisper API the transport expects.

Takeaway

Live props are the most significant Inertia feature since partial reloads. They remove the boilerplate that made real-time feel like a side project and let you declare "this prop updates when that event broadcasts" in one line on the server. For the majority of Laravel + Inertia applications — order tracking, admin panels, status pages — this is the right abstraction.

Sources