Laravel Inertia: Qué es, Cómo Funciona y Por Qué Usarlo en tu Proyecto

- Andrés Cruz - EN In english

Video thumbnail

Cuando empiezas a trabajar con Laravel y quieres una experiencia realmente fluida entre backend y frontend, inevitablemente acabas mirando Inertia.js. Y no es para menos: te permite crear una SPA sin montar una API REST completa, sin pelearte con Vue Router, ni duplicar lógica entre cliente y servidor.

La primera vez que probé Inertia y creé un nuevo proyecto en Laravel con Inertia, venía de proyectos con Breeze y Blade, así que me sorprendió lo natural que se siente trabajar con él… casi como si Laravel pudiera renderizar Vue de forma nativa. Y esa, precisamente, es la pieza clave y la característica principal de este stack.

En este artículo te cuento todas las características de Laravel Inertia, cómo funciona por dentro y por qué está ganando tanto terreno entre los desarrolladores de Laravel.

Qué es Laravel Inertia y por qué resuelve tantos problemas

El problema clásico de las SPA con API separada

El enfoque tradicional de una SPA (API + cliente JS) arrastra dos efectos secundarios que todo desarrollador Laravel conoce bien:

  • Tienes que duplicar conceptos: rutas en routes/web.php de Laravel y rutas en Vue Router o React Router.
  • Pierdes funcionalidades nativas como sesiones, middlewares o la validación de formularios de Laravel, que tienes que reimplementar o coordinar manualmente en el cliente.

Además, montar un CRUD completo termina siendo más complejo de lo necesario: una parte vive en Laravel, otra en el frontend… y son dos mundos que hay que mantener en sincronía constante.

Cómo Inertia mezcla lo mejor del SSR y del SPA

Inertia simplifica todo esto devolviendo componentes JavaScript directamente desde los controladores de Laravel. No necesitas una API REST para mostrar datos: Laravel pasa props al componente Vue (o React) y listo.

La magia ocurre porque Inertia intercepta las peticiones y evita recargas de página completa. El resultado es una experiencia SPA —navegación sin parpadeo, estado del frontend preservado— pero con toda la simplicidad del flujo servidor de Laravel.

Recuerdo que cuando revisé mis controladores por primera vez pensé: "esto funciona igual que con Blade… solo que lo que se renderiza es un componente Vue". Y ahí fue cuando me terminó de convencer. Lo bonito de Inertia es que supone una evolución muy suave de lo que ya tenemos en Laravel: simplemente devolvemos un componente .vue en lugar de una vista .blade.php, con cambios mínimos para que todo funcione como esperas.

¿Qué nos ofrece Inertia?

Crear aplicaciones web modernas es difícil. Herramientas como Vue y React son extremadamente poderosas, pero la complejidad que agregan al flujo de trabajo de un desarrollador fullstack puede llegar a ser desproporcionada.

Integrar Vue en un proyecto Laravel no es una tarea especialmente difícil —puedes hacerlo vía npm o la CDN y comunicar ambos mediante una REST API—, pero el "problema" con ese enfoque es que implica trabajar en muchas capas y tecnologías diferentes y luego interconectarlas todas.

El flujo clásico sería: Laravel con toda su lógica de servidor, una REST API, las vistas con Blade, y encima el proyecto Vue consumiendo esa API con axios o fetch. Es un camino laborioso que con Inertia podemos simplificar y optimizar de forma considerable.

Pensando en todo lo anterior, Laravel Inertia es un adaptador completo que simplifica la creación de interfaces dinámicas sin abandonar la comodidad de Laravel. En pocas palabras: nos permite comunicar fácilmente Laravel con Vue (y viceversa) sin necesidad de una API intermedia.

¿Qué es Inertia y por qué compararlo con Livewire?

Es inevitable comparar Inertia con Livewire. Ambos nacieron bajo el paraguas de Jetstream, pero con el tiempo han tomado caminos muy distintos. Antiguamente Inertia se sentía como un añadido de Jetstream, pero a partir de la versión 1.0 (y ahora en la 3.0), se ha integrado directamente en el núcleo de Laravel.

Hoy, cuando instalas un proyecto nuevo de Laravel 13, Inertia es una de las opciones oficiales del instalador. Puedes usarlo con:

  • Vue.js (el que utilizaremos a lo largo de este libro).
  • React.
  • Svelte.

Si inspeccionamos un proyecto recién generado con Laravel + Inertia, veremos en el package.json:

{
    "$schema": "https://www.schemastore.org/package.json",
    "private": true,
    "type": "module",
    "scripts": {
        "build": "vite build",
        "build:ssr": "vite build && vite build --ssr",
        "dev": "vite",
        "format": "prettier --write resources/",
        "format:check": "prettier --check resources/",
        "lint": "eslint . --fix",
        "lint:check": "eslint .",
        "types:check": "vue-tsc --noEmit"
    },
    "devDependencies": {
        "@eslint/js": "^9.19.0",
        "@stylistic/eslint-plugin": "^5.10.0",
        "@laravel/vite-plugin-wayfinder": "^0.1.3",
        "@tailwindcss/vite": "^4.1.11",
        "@types/node": "^22.13.5",
        "@vitejs/plugin-vue": "^6.0.0",
        ***
        "prettier-plugin-tailwindcss": "^0.6.11",
        "typescript": "^5.2.2",
        "typescript-eslint": "^8.23.0",
        "vite": "^8.0.0",
        "vue-tsc": "^2.2.4"
    },
    "dependencies": {
        "@inertiajs/vite": "^3.0.0",
        "@inertiajs/vue3": "^3.0.0",
        "@vueuse/core": "^12.8.2",
        "class-variance-authority": "^0.7.1",
        "clsx": "^2.1.1",
        "laravel-vite-plugin": "^3.0.0",
        "lucide-vue-next": "^0.468.0",
        "reka-ui": "^2.6.1",
        "tailwind-merge": "^3.2.0",
        "tailwindcss": "^4.1.1",
        "tw-animate-css": "^1.2.5",
        "vue": "^3.5.13",
        "vue-input-otp": "^0.3.2"
    },
    "optionalDependencies": {***
}

Ahí están Vue e Inertia listos. Si revisamos el composer.json, veremos su contraparte en PHP:

"require": {
    "php": "^8.3",
    "inertiajs/inertia-laravel": "^3.0",
    "laravel/fortify": "^1.34",
    "laravel/framework": "^13.0",
    "laravel/tinker": "^3.0",
    "laravel/wayfinder": "^0.1.14"
},

Características principales de Laravel Inertia (la lista completa)

Aquí sí vamos a hacer lo que los competidores no hacen: una lista clara, completa y bien explicada de todo lo que trae Inertia.

Renderizado con Inertia

El núcleo de Inertia es simple: renderizar componentes Vue (o React, si así lo prefieres) en lugar de archivos Blade. Desde el controlador, en vez de retornar view('users.show'), retornamos:

return Inertia::render('Users/Show', [
    'user' => $user
]);

Y eso es todo. Laravel entrega un componente Vue/React completamente hidratado con los datos, sin necesidad de un endpoint adicional. Lo mismo ocurre en todas las vistas de la aplicación: si inspeccionas los controladores, verás que los nombres son bastante descriptivos y cubren el flujo completo de autenticación (login, registro, recuperación de contraseña, etc.).

Props: comunicación directa servidor → cliente

Laravel envía datos directamente al componente como props, exactamente igual que lo haría con variables en Blade. No necesitas axios, ni fetch, ni endpoints adicionales para hidratar la vista inicial. El controlador es la única fuente de verdad.

Vistas controladas por controladores

En Inertia, las vistas se renderizan siempre desde los controladores, igual que en Laravel tradicional con Blade. Si quieres mostrar algo, defines una ruta, apuntas a un controlador y desde ahí llamas a Inertia::render(). No hay magia adicional ni convenciones extrañas: el flujo es el mismo de siempre.

Middleware y datos globales con HandleInertiaRequests

Laravel incluye un middleware recomendado llamado HandleInertiaRequests. Este middleware actúa como un intermediario entre el servidor y todos los componentes: es el lugar ideal para pasar datos globales, como el usuario autenticado, traducciones o mensajes flash.

Los mensajes flash son esas notificaciones temporales que aparecen tras realizar una acción —por ejemplo, después de guardar un formulario con éxito—. Al configurarlos en HandleInertiaRequests, quedan disponibles en todas las vistas sin necesidad de pasarlos manualmente en cada controlador.

Enrutamiento clásico de Laravel con experiencia SPA

Todas tus rutas siguen siendo rutas de Laravel definidas en routes/web.php. Inertia no introduce su propio sistema de rutas: simplemente intercepta la navegación del lado del cliente y la convierte en una petición XHR interna, evitando la recarga completa de la página. Resultado: experiencia SPA, arquitectura Laravel.

Modelo de usuario y autenticación

El modelo User que genera Inertia es completamente estándar: incluye los traits Authenticatable, HasFactory y Notifiable, igual que en cualquier proyecto Laravel. La autenticación funciona exactamente igual que siempre; Inertia no toca nada de esta capa.

¿Dónde están las vistas?

Si revisas la carpeta resources/views, verás que solo existe un único archivo Blade. Esto genera confusión al principio, pero la explicación es sencilla: las demás "vistas" son componentes Vue.

Por cada página que ves en el navegador, hay un componente detrás. Y están organizados de forma muy clara:

  • Pages/: contiene las páginas completas de la aplicación.
  • Components/: contiene las piezas reutilizables con las que se arman esas páginas.

La estructura está bien modularizada y es fácil de navegar incluso en proyectos grandes.

Integración con autenticación y sesiones de Laravel

Lo mejor de todo: no cambias absolutamente nada. Las sesiones, los middlewares, los guards de autenticación… funcionan exactamente igual que siempre. Cuando reconstruí mi sistema de login y registro en Inertia, prácticamente reutilicé la lógica de Blade, transformando únicamente las vistas en componentes Vue.

Layouts y estructura de la aplicación

Inertia fomenta una estructura amplia pero muy ordenada. Además de Pages/ y Components/, tenemos la carpeta Layouts/, que contiene las plantillas globales compartidas entre páginas.

El archivo de arranque (app.ts o app.js) es donde se inicializa la aplicación. Aquí también encontramos el único archivo Blade del proyecto: app.blade.php. Inertia lo rastrea automáticamente como plantilla principal, así que no debes moverlo ni cambiarle el nombre.

  • /Pages → páginas completas
  • /Components → piezas reutilizables
  • /Layouts → plantillas globales

Navegación con <Link> y peticiones XHR inteligentes

Inertia reemplaza los enlaces HTML tradicionales con su propio componente <Link>:

<Link href="/posts/1">Ver post</Link>

Al hacer clic, en lugar de recargar la página, Inertia lanza una petición XHR al servidor, recibe el nuevo componente con sus props y actualiza solo la parte de la UI que cambia. El estado del frontend se preserva y la URL cambia correctamente.

Gestión de estado mínima sin store externo

No siempre hace falta Vuex, Pinia o Redux. El patrón "controlador → props → componente" de Inertia reduce drásticamente la necesidad de un store global, porque el servidor siempre es la fuente de verdad. Esto simplifica enormemente el estado de la aplicación y facilita el mantenimiento a largo plazo.

Inicialización de la app con Inertia

El arranque de la app es similar al de cualquier proyecto Vue, pero utilizando createInertiaApp() en lugar de createApp() directamente. En este bloque indicamos:

  • La ruta donde están nuestras páginas (./pages/).
  • Dónde se van a montar los componentes (el elemento raíz del DOM).
  • Los plugins adicionales que necesitamos (como la barra de progreso de navegación).
createInertiaApp({
    title: (title) => `${title} - ${appName}`,
    resolve: (name) => resolvePageComponent(`./pages/${name}.vue`, import.meta.glob<DefineComponent>('./pages/**/*.vue')),
    setup({ el, App, props, plugin }) {
        createApp({ render: () => h(App, props) })
            .use(plugin)
            .use(Oruga)
            .use(CkeditorPlugin)
            .use(ZiggyVue)
            .mount(el);

Todo esto ocurre en el archivo de arranque y raramente necesitas tocarlo una vez configurado.

Ubicación y uso de los componentes

Como ya vimos, las páginas están en Pages/ y los elementos reutilizables en Components/. Inertia resuelve automáticamente qué componente mostrar basándose en el nombre que le pases a Inertia::render(), así que la organización de carpetas es importante y conviene mantenerla coherente desde el principio.

Manejo de formularios con Inertia

Una diferencia importante respecto a una aplicación Vue tradicional es el manejo de formularios. Aquí no usamos axios directamente. En su lugar, Inertia nos proporciona el composable useForm:

const form = useForm({
    name: '',
    email: ''
});
form.post('/users');

useForm lo importamos directamente de @inertiajs/vue3 y nos permite manejar el estado del formulario, el envío, los errores de validación del servidor y los estados de carga —todo en un único objeto—, sin escribir una sola línea de código axios ni gestionar manualmente la respuesta del servidor.

Vue Router e Inertia en Laravel

Video thumbnail

Con Laravel Inertia obtenemos automáticamente una navegación tipo SPA (Single Page Application): el render del cliente lo gestiona Vue, así que los enlaces HTML tradicionales (<a href="...">) no deben usarse para la navegación interna, ya que provocan una recarga completa de la página.

Puedes comprobarlo fácilmente: si colocas un enlace <a> convencional dentro de tu app y haces clic, verás que toda la página se recarga. Lo que queremos, en cambio, es que la navegación ocurra solo dentro del contenedor de la aplicación —normalmente <div id="app">—, actualizando únicamente el componente correspondiente sin recargar el layout ni el estado global.

import { Link } from "@inertiajs/vue3"

Cuándo usar enlaces tradicionales

Usar <a href="..."> no está prohibido. Tiene sentido para enlaces externos, como URLs a páginas de terceros o sitios que no forman parte de nuestra aplicación. Para cualquier navegación interna, sin embargo, siempre debemos utilizar el componente <Link> de Inertia.

Inertia reemplaza a Vue Router

En un proyecto Vue estándar usarías Vue Router para manejar la navegación SPA. Con Inertia, Vue Router no es necesario, porque Inertia implementa internamente el cambio de URL y la carga de componentes. Si los combinases, ambos procesos se solaparían y generarían conflictos difíciles de depurar. Por eso, Inertia proporciona su propio componente <Link> como sustituto directo.

Importación del componente Link

En Vue 3, importamos <Link> de la siguiente manera:

import { Link } from "@inertiajs/vue3"

Es una importación con nombre, así que debemos respetar el nombre Link tal cual. No podemos asignarle un alias arbitrario como Link2, ya que no será reconocido por Inertia:

// Incorrecto
import { Link2 } from "@inertiajs/vue3" // Esto dará error

Una vez importado, podemos usarlo dentro de nuestros componentes de la misma forma en que usaríamos un <a> en HTML:

import AppLayout from "@/Layouts/AppLayout.vue"

Uso básico del componente Link

El uso de <Link> es muy sencillo. Funciona como un <a> normal, pero mantiene la navegación SPA e integra el helper route() de Ziggy para generar URLs tipadas:

<Link class="text-sm text-purple-400 hover:text-purple-700"
     :href="route('category.edit', c.id)">
 Edit
</Link>
  • :href="route('category.edit', c.id)" genera la URL de la ruta usando el helper route() de Ziggy, que expone las rutas con nombre de Laravel al frontend.

Al hacer clic, no se recarga toda la página: solo se actualiza el componente correspondiente, la URL cambia correctamente y el título de la página se actualiza, respetando el comportamiento esperado de una SPA.

También puedes crear enlaces para otras acciones, como navegar a la vista de creación:

<Link class="link-button-default my-3" :href="route('category.create')">
 Create
</Link>

En resumen, con Inertia tienes:

  • Navegación SPA sin recargar toda la página.
  • Manejo de rutas y URLs de forma sencilla, segura y tipada gracias a route().
  • Eliminación completa de Vue Router para la navegación interna.

Esto nos permite integrar de manera eficiente la navegación de todos los módulos y componentes, manteniendo la aplicación rápida, fluida y fácil de mantener.

Ventajas reales de trabajar con Laravel Inertia

Ahorro de tiempo frente a montar API + SPA

  • No duplicas rutas, no creas controladores API, no configuras servicios axios para cada endpoint. Todo el flujo de datos pasa por Laravel de forma directa.
  • Curva de aprendizaje mínima para desarrolladores Laravel. Si vienes de Blade, te sientes en casa desde el primer día. A mí me pasó exactamente eso: comencé migrando vistas a componentes Vue y en una tarde ya tenía el flujo completo montado y funcionando.
  • Integración nativa con Vue, React y Svelte. Como el backend entrega props directamente a los componentes, el frontend es extremadamente limpio: sin stores globales innecesarios, sin lógica de fetching repetitiva.

¿Cuándo elegir Inertia.js sobre Blade o Livewire?

Comparación rápida

  • Blade: perfecto para sitios tradicionales o aplicaciones con poca interactividad en el cliente.
  • Livewire: ideal cuando no quieres escribir JavaScript pero necesitas reactividad en tiempo real.
  • Inertia: la mejor opción para aplicaciones modernas que combinan la solidez de Laravel con Vue, React o Svelte en el frontend.

Casos de uso recomendados

  • Paneles de administración y dashboards.
  • Sistemas CRUD complejos.
  • Aplicaciones con lógica de servidor compleja pero vistas altamente dinámicas.
  • Proyectos donde quieres experiencia SPA sin el overhead de crear y mantener una API REST separada.

Preguntas frecuentes sobre Laravel Inertia

  • ¿Inertia reemplaza a Blade?
    • No completamente: en un proyecto con Inertia solo necesitarás un archivo Blade (app.blade.php), que actúa como cáscara HTML. El resto de las vistas son componentes Vue/React/Svelte.
  • ¿Puedo usar Inertia sin Vue?
    • Sí, Inertia tiene adaptadores oficiales para React y Svelte además de Vue.
  • ¿Es buena opción para proyectos grandes?
    • Sí. Precisamente porque mantiene toda la lógica de negocio en Laravel y deja el frontend modular y bien separado, escala correctamente.
  • ¿Qué pasa con el SEO en una SPA con Inertia?
    • Inertia soporta SSR (Server-Side Rendering) mediante un servidor Node. Con SSR habilitado, el servidor entrega HTML renderizado al bot del buscador, resolviendo el problema clásico de indexación de las SPA.

Conclusión

Laravel Inertia combina lo mejor del servidor y del cliente sin obligarte a crear una API REST completa ni un router JS complejo. Si ya trabajas con Laravel, adoptar Inertia se siente casi natural: controladores, rutas, middleware, validación… todo sigue funcionando igual, pero el frontend se vuelve mucho más dinámico y potente.

En mi experiencia, la curva de aprendizaje es mínima y el desarrollo se vuelve muy ágil: un login, un CRUD o un dashboard se montan en la mitad de tiempo comparado con una SPA tradicional con API REST separada.

Si buscas flexibilidad, velocidad y una arquitectura limpia que no te obligue a abandonar lo que ya sabes de Laravel, Inertia.js es de las mejores opciones disponibles en el desarrollo web moderno.

Descubre qué es Inertia.js en Laravel, cómo reemplaza a Vue Router, cómo funciona el renderizado de componentes y cuándo elegirlo sobre Blade o Livewire. Guía completa con ejemplos


Únete a la comunidad de desarrolladores que han decidido dejar de picar código y empezar a construir productos reales. Recibe mis mejores trucos de arquitectura cada semana:

Acepto recibir anuncios de interes sobre este Blog.