What is route model binding?

Question

Accepted Answer

**Route model binding** automatically injects model instances into routes/controllers based on route parameters — so instead of manually fetching a model by its id, Laravel resolves and injects it for you (returning a 404 automatically if not found). It's an elegant convenience that reduces boilerplate.

## Implicit binding (the common case)

```php
// the route parameter name matches the type-hinted model's variable
Route::get('/users/{user}', [UserController::class, 'show']);

public function show(User $user) {          // type-hint User → auto-resolved by id
    return $user;                            // $user is the User with that id
}
// GET /users/5 → Laravel runs User::findOrFail(5) and injects it (404 if not found)
```

When you type-hint a model (`User $user`) and the route parameter name matches (`{user}`), Laravel **automatically fetches the model by its id** and injects it — replacing the manual `User::findOrFail($id)` you'd otherwise write, and returning a 404 automatically if the record doesn't exist.

## Without vs with route model binding

```php
// ❌ without — manual fetching and 404 handling
public function show($id) {
    $user = User::findOrFail($id);   // fetch + 404 by hand
    return $user;
}

// ✅ with route model binding — Laravel does it for you
public function show(User $user) {   // injected, 404 handled automatically
    return $user;
}
```

## Customizing the binding (by a different column)

```php
// bind by a column other than id (e.g. a slug)
Route::get('/posts/{post:slug}', ...);    // resolves Post by its `slug` column

// or define a custom key on the model:
public function getRouteKeyName() { return 'slug'; }
```

By default it binds by primary key, but you can bind by any column (e.g. a `slug`) — useful for friendly URLs.

## Scoped bindings (nested resources)

```php
// ensure the comment belongs to the post (scoped to the parent)
Route::get('/posts/{post}/comments/{comment}', ...);   // auto-scoped in Laravel
```

## Why it matters

Route model binding is a convenient, frequently-used Laravel feature that reduces boilerplate and makes controllers cleaner, so understanding it is valuable everyday knowledge for building Laravel applications.

Its core benefit is **automating the common pattern** of fetching a model by its route parameter: instead of manually writing `Model::findOrFail($id)` (plus 404 handling) in every controller method, you simply type-hint the model and Laravel resolves and injects it automatically — including returning a 404 if the record doesn't exist.

This eliminates repetitive fetch-and-check code across nearly every show/edit/update/delete action (which is most of a CRUD app), keeping controllers focused and clean.

Understanding implicit binding (the common case), how to **customize the binding column** (e.g. binding by a `slug` instead of id for friendly URLs — a common need), and scoped bindings for nested resources covers the practical uses.

Since route model binding appears throughout Laravel applications (any route that operates on a specific model uses it), and since it embodies the framework's emphasis on reducing boilerplate and elegant convenience, knowing how it works and how to customize it is important, practical knowledge that lets you write cleaner controllers and leverage one of Laravel's many quality-of-life features effectively.