> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Enrutamiento

> Explicamos cómo definir rutas en Laravel, los parámetros de ruta y las bases de las rutas con nombre.

## Enrutamiento básico

Las rutas más básicas de Laravel reciben un URI y una closure.
Puedes definir rutas y sus comportamientos con facilidad, sin archivos de configuración complejos.

```php theme={null}
use Illuminate\Support\Facades\Route;

Route::get('/greeting', function () {
    return 'Hello World';
});
```

### Archivos de ruta por defecto

Todas las rutas de Laravel se definen en los archivos del directorio `routes/`.
Laravel los carga automáticamente en función de la configuración en `bootstrap/app.php`.

```mermaid theme={null}
flowchart LR
    A["Solicitud entrante"] --> B{{"Tipo de solicitud"}}
    B -->|"Para navegador<br>Sesión / CSRF"| C["routes/web.php<br>Grupo de middleware web"]
    B -->|"Para API<br>Sin estado"| D["routes/api.php<br>Grupo de middleware api"]
    B -->|"Comando CLI"| E["routes/console.php<br>Definición de comandos Artisan"]
    C --> F["Controlador / Closure"]
    D --> F
    E --> G["Manejador del comando"]
```

Define en `routes/web.php` las rutas dirigidas al navegador.
A las rutas de este archivo se les aplica el grupo de middleware `web`, que aporta sesión, protección CSRF y cifrado de cookies.

```php theme={null}
use App\Http\Controllers\UserController;

Route::get('/user', [UserController::class, 'index']);
```

### Rutas de API

Si la aplicación ofrece una API sin estado, puedes habilitar el enrutamiento de API con el comando Artisan `install:api`.

```shell theme={null}
php artisan install:api
```

El comando `install:api` instala [Laravel Sanctum](/es/sanctum) y crea el archivo `routes/api.php`.
Sanctum ofrece un guard sencillo y robusto de autenticación por API tokens para consumidores externos, SPAs y aplicaciones móviles.

```php theme={null}
Route::get('/user', function (Request $request) {
    return $request->user();
})->middleware('auth:sanctum');
```

Las rutas de `routes/api.php` son sin estado y se les aplica el [grupo de middleware](/es/middleware) `api`.
Además, se aplica automáticamente el prefijo `/api` a todas las rutas, por lo que no necesitas añadirlo manualmente.
Para cambiar el prefijo, edita el archivo `bootstrap/app.php`.

```php theme={null}
->withRouting(
    api: __DIR__.'/../routes/api.php',
    apiPrefix: 'api/admin',
    // ...
)
```

### Métodos HTTP disponibles

El router permite registrar rutas para todos los métodos HTTP.

```php theme={null}
Route::get($uri, $callback);
Route::post($uri, $callback);
Route::put($uri, $callback);
Route::patch($uri, $callback);
Route::delete($uri, $callback);
Route::options($uri, $callback);
```

Para rutas que responden a varios métodos HTTP, usa `match` o `any`.

```php theme={null}
Route::match(['get', 'post'], '/', function () {
    // ...
});

Route::any('/', function () {
    // ...
});
```

<Info>
  En los formularios HTML que envían `POST`, `PUT`, `PATCH` o `DELETE` a rutas de `web`, incluye siempre la directiva `@csrf`.
  Sin ella, la solicitud será rechazada.
</Info>

## Rutas que devuelven una vista

Si la ruta simplemente devuelve una vista, `Route::view` te permite escribirlo de forma concisa.

```php theme={null}
Route::view('/welcome', 'welcome');

// Con datos para la vista
Route::view('/welcome', 'welcome', ['name' => 'Taylor']);
```

## Parámetros de ruta

### Parámetros obligatorios

Para capturar parte de la URL de forma dinámica, usa parámetros de ruta.
Se encierran entre `{}` y se reciben como argumentos del callback.

```php theme={null}
Route::get('/user/{id}', function (string $id) {
    return 'ID de usuario: ' . $id;
});
```

También puedes definir varios parámetros.

```php theme={null}
Route::get('/posts/{post}/comments/{comment}', function (string $postId, string $commentId) {
    return "Comentario {$commentId} del post {$postId}";
});
```

<Warning>
  Los parámetros de ruta no pueden contener el carácter `/`.
</Warning>

### Parámetros opcionales

Para hacer opcional un parámetro, añade `?` al final de su nombre y proporciona un valor por defecto en el argumento correspondiente.

```php theme={null}
Route::get('/user/{name?}', function (?string $name = null) {
    return $name ?? 'Invitado';
});

Route::get('/user/{name?}', function (?string $name = 'Invitado') {
    return $name;
});
```

### Restricción de parámetros con expresiones regulares

Con el método `where` puedes restringir el formato del parámetro mediante una expresión regular.

```php theme={null}
Route::get('/user/{id}', function (string $id) {
    // ...
})->where('id', '[0-9]+');

Route::get('/user/{name}', function (string $name) {
    // ...
})->where('name', '[a-zA-Z]+');
```

Los patrones más habituales tienen métodos abreviados.

```php theme={null}
Route::get('/user/{id}/{name}', function (string $id, string $name) {
    // ...
})->whereNumber('id')->whereAlpha('name');
```

## Rutas con nombre

Las rutas con nombre te permiten generar URLs o hacer redirecciones referenciando la ruta por su nombre.

```php theme={null}
Route::get('/user/profile', function () {
    // ...
})->name('profile');
```

### Generar URLs de rutas con nombre

Genera URLs a partir del nombre de la ruta con el helper `route`.

```php theme={null}
// Generar URL
$url = route('profile');

// Generar URL con parámetros
$url = route('user.show', ['id' => 1]);
```

### Redirección

```php theme={null}
return redirect()->route('profile');
```

## Grupos de rutas

Puedes agrupar rutas relacionadas para compartir configuración de middlewares, controlador, prefijo, etc.

```mermaid theme={null}
flowchart TD
    A["Solicitud HTTP"] --> B["Router"]
    B --> C{{"¿Existe una ruta<br>que coincida?"}}
    C -->|"No"| D["Respuesta 404"]
    C -->|"Sí"| E["Se comprueban los middlewares de la ruta"]
    E --> F{{"¿Los middlewares<br>lo permiten?"}}
    F -->|"Rechazado"| G["Redirección /<br>respuesta de error"]
    F -->|"Aceptado"| H["Ejecución del controlador /<br>closure"]
    H --> I["Se genera la respuesta"]
    I --> J["Envío al cliente"]
```

### Middleware

```php theme={null}
Route::middleware(['auth'])->group(function () {
    Route::get('/dashboard', function () {
        // Solo accesible por usuarios autenticados
    });

    Route::get('/account', function () {
        // Solo accesible por usuarios autenticados
    });
});
```

### Controlador

Agrupa las rutas que usan el mismo controlador.

```php theme={null}
use App\Http\Controllers\OrderController;

Route::controller(OrderController::class)->group(function () {
    Route::get('/orders', 'index');
    Route::post('/orders', 'store');
    Route::get('/orders/{id}', 'show');
});
```

### Prefijo

Añade un prefijo común a los URIs de un grupo de rutas.

```php theme={null}
Route::prefix('admin')->group(function () {
    Route::get('/users', function () {
        // Accesible en /admin/users
    });
    Route::get('/posts', function () {
        // Accesible en /admin/posts
    });
});
```

## Listar rutas

Para ver todas las rutas definidas, usa el comando Artisan:

```shell theme={null}
php artisan route:list
```

Para mostrar también la información de middlewares:

```shell theme={null}
php artisan route:list -v
```

Para mostrar solo las rutas que empiezan por un URI concreto:

```shell theme={null}
php artisan route:list --path=user
```

## Próximos pasos

<Card title="Vistas" icon="eye" href="/es/views">
  Aprende a crear vistas y a pasarles datos desde los controladores.
</Card>


## Related topics

- [Ciclo de vida de la solicitud](/es/lifecycle.md)
- [Actualización de Laravel — Marzo de 2026](/es/blog/changelog/202603.md)
- [Resumen de las novedades de Laravel 13](/es/blog/laravel-13-new-features.md)
- [Laravel Folio](/es/folio.md)
- [Verificación de correo electrónico (Email Verification)](/es/verification.md)