Route Model Binding in Laravel

Dilip Published: Categories: Laravel

When building applications in Laravel, we often need to fetch a record from the database using an ID from the URL. Laravel provides a very helpful feature called Route Model Binding that makes this process much simpler.

In this post, we will learn:

  • What Route Model Binding is
  • How it works
  • How to use it in your project
  • Why it is useful

What is Route Model Binding?

Route Model Binding is a feature where Laravel automatically fetches a model from the database using the route parameter.

Instead of manually writing a query to find a record, Laravel does it for you.

For example, if your URL looks like this:

/members/5

Laravel can automatically fetch the member with ID 5 from the database and pass it to your controller.

Without Route Model Binding

Normally, we write code like this.

Route

Route::get('/members/{id}', [MemberController::class, 'show']);

Controller

public function show($id)
{
    $member = Member::findOrFail($id);

    return view('members.show', compact('member'));
}

Here we:

  1. Receive the $id
  2. Query the database using findOrFail()
  3. Store the result in $member

This works fine, but we need to write this logic again in multiple methods like show, edit, update, and delete.

With Route Model Binding

Laravel can automatically fetch the model for us.

Route

Route::get('/members/{member}', [MemberController::class, 'show']);

Notice the parameter name {member}.

Controller

public function show(Member $member)
{
    return view('members.show', compact('member'));
}

Now Laravel automatically:

  1. Reads the {member} value from the URL
  2. Finds the record in the database
  3. Injects the Member model into the controller

No need to call findOrFail() anymore.

Example: Update Method

Without route model binding:

public function update(Request $request, $id)
{
    $member = Member::findOrFail($id);

    $member->update($request->all());

    return redirect()->route('members.show', $member->id);
}

With route model binding:

public function update(Request $request, Member $member)
{
    $member->update($request->all());

    return redirect()->route('members.show', $member->id);
}

The controller becomes shorter and cleaner.

Benefits of Route Model Binding

Cleaner Controllers

You don’t need to manually fetch models using find() or findOrFail().

Less Repeated Code

The same database lookup code does not need to be written in multiple controller methods.

Automatic 404 Handling

If the model is not found, Laravel automatically returns a 404 page.

Better Readability

When you see this:

public function edit(Member $member)

You immediately understand that this method works with a Member model.

Works Great with Resource Controllers

If you use resource routes:

Route::resource('members', MemberController::class);

Laravel automatically uses route model binding for methods like:

  • show
  • edit
  • update
  • destroy

This makes CRUD controllers very clean.

Request Classes in Laravel

Another feature that helps keep controllers clean is Form Request Classes.

Instead of writing validation inside controllers, we can move it to a separate request class.

Creating a Request Class

Laravel provides an Artisan command to create a request class.

php artisan make:request MemberRequest

This command creates a new file inside:

app/Http/Requests/MemberRequest.php

This class is used to handle validation and authorization for incoming requests.

Example Request Class

class MemberRequest extends FormRequest
{
    public function authorize()
    {
        return true;
    }

    public function rules()
    {
        $memberId = $this->route('member') ? $this->route('member')->id : null;

        return [
            'name' => 'required|string|max:20',
            'email' => [
                'required',
                'email',
                'max:50',
                Rule::unique('members', 'email')->ignore($memberId),
            ],
            'phone' => [
                'required',
                'string',
                'max:30',
                Rule::unique('members', 'phone')->ignore($memberId),
            ],
            'status' => 'required|in:active,inactive',
            'note' => 'nullable|string',
        ];
    }
}

Here we define all validation rules inside the request class.

Using the Request Class in Controller

Instead of using the normal request, we use our custom request class.

public function store(MemberRequest $request)
{
    Member::create($request->validated());

    return redirect()->route('members.index');
}

Laravel will automatically:

  1. Run validation
  2. Redirect back if validation fails
  3. Provide validated data using $request->validated()

Benefits of Using Request Classes

Cleaner Controllers

Controllers only handle application logic.

Reusable Validation

The same request class can be reused in multiple places.

Better Organization

Validation rules stay inside request classes instead of cluttering controllers.

Automatic Validation

Laravel automatically runs validation before the controller method executes.

Conclusion

Both Route Model Binding and Request Classes help simplify Laravel applications.

Route Model Binding automatically retrieves models from route parameters, while Request Classes move validation logic outside controllers.

Using these two features together helps you:

  • Write cleaner controllers
  • Reduce repeated code
  • Organize validation logic properly

These small improvements make Laravel applications easier to read, maintain, and scale as the project grows.