When building a Laravel application, different parts of your database usually need to connect with each other.

For example, a user can write multiple blog posts, a post can have multiple comments, and users can have different roles. Managing these connections manually with SQL queries can become complicated.

This is where Laravel Eloquent Relationships make things easier.

Laravel’s Eloquent ORM allows you to define relationships between models using simple and readable PHP methods. Once the relationship is defined, you can easily retrieve and work with related data without writing complex SQL joins every time.

In this guide, we’ll explain the most important Laravel Eloquent relationships with simple examples and real-world use cases.

What Are Laravel Eloquent Relationships?

An Eloquent relationship defines how one model is connected to another model in your database.

Let’s take a simple example.

A user can create multiple posts:

User
  ├── Post 1
  ├── Post 2
  └── Post 3

In the database, the posts table usually contains a user_id column.

users
----------------
id | name
1  | John

posts
------------------------
id | user_id | title
1  | 1       | Laravel Basics
2  | 1       | Eloquent Guide

The user_id acts as a foreign key and connects each post with its owner.

Laravel allows you to define this connection directly inside your models.

---

Why Use Eloquent Relationships?

Without Eloquent relationships, you may need to manually query related tables and manage joins.

With relationships, Laravel gives you a much cleaner approach.

For example:

$user->posts;

Laravel understands that you want to retrieve all posts belonging to that user.

Some major benefits include:

• Cleaner and more readable code
• Less repetitive SQL
• Easy access to related data
• Support for eager loading
• Better organization of database logic
• Convenient methods for creating and updating related records

---

Main Types of Laravel Eloquent Relationships

Laravel provides several relationship types, but these are the ones you will use most often:

Relationship	Example
One-to-One	User → Profile
One-to-Many	User → Posts
Many-to-Many	Users ↔ Roles
Has One Through	Mechanic → Car → Owner
Has Many Through	Country → Users → Posts
Polymorphic	Comments → Posts or Videos

Let’s understand them one by one.

---

1. One-to-One Relationship

A one-to-one relationship means one record is associated with one other record.

Real-world example

A user has one profile.

User
  ↓
Profile

Your database might look like this:

users
----------------
id | name

profiles
----------------
id | user_id | bio

The relationship can be defined in the User model:

public function profile()
{
    return $this->hasOne(Profile::class);
}

Now you can access the profile easily:

$user->profile;

The reverse relationship belongs in the Profile model:

public function user()
{
    return $this->belongsTo(User::class);
}

When should you use it?

Use a one-to-one relationship when additional information belongs to exactly one record.

Examples include:

• User → Profile
• User → Address
• User → Settings
• Employee → Employee Details

---

2. One-to-Many Relationship

The one-to-many relationship is one of the most commonly used Laravel relationships.

It means one record can have multiple related records.

Real-world example

One user can write many posts.

User
  ├── Post
  ├── Post
  └── Post

The relationship in the User model is:

public function posts()
{
    return $this->hasMany(Post::class);
}

You can then retrieve all posts for a user:

$user->posts;

The reverse relationship is added to the Post model:

public function user()
{
    return $this->belongsTo(User::class);
}

Now you can find the owner of a post:

$post->user;

When should you use it?

Common examples include:

• User → Posts
• Customer → Orders
• Category → Products
• Post → Comments
• Company → Employees

If one model owns multiple records of another model, this relationship is usually the right choice.

---

3. Many-to-Many Relationship

A many-to-many relationship means multiple records from one model can be connected to multiple records from another model.

Real-world example

A user can have multiple roles:

User
  ├── Admin
  └── Editor

At the same time, the Admin role can belong to many users.

Users
   ↕
Roles

Laravel manages this using a pivot table.

For example:

users
roles
role_user

The role_user table stores the connection between users and roles.

In the User model:

public function roles()
{
    return $this->belongsToMany(Role::class);
}

Now you can retrieve all roles assigned to a user:

$user->roles;

Laravel also provides useful methods for managing many-to-many relationships.

For example:

$user->roles()->sync([1, 2]);

This updates the user’s roles based on the provided IDs.

Common examples

Many-to-many relationships are useful for:

• Users ↔ Roles
• Posts ↔ Tags
• Students ↔ Courses
• Products ↔ Categories
• Users ↔ Permissions

---

What Is a Pivot Table in Laravel?

A pivot table is an intermediate table used to connect two models in a many-to-many relationship.

For example:

users
-----
id

roles
-----
id

role_user
---------
user_id
role_id

The role_user table does not necessarily need its own model for basic relationships.

Laravel automatically understands how to work with the pivot table when using belongsToMany().

This makes managing many-to-many relationships much easier.

---

4. Has One Through Relationship

A hasOneThrough relationship allows you to access one model through another intermediate model.

Example

Imagine this structure:

Mechanic
   ↓
Car
   ↓
Owner

A mechanic works on a car, and the car belongs to an owner.

Using hasOneThrough(), Laravel allows you to access the owner through the car.

public function carOwner()
{
    return $this->hasOneThrough(
        Owner::class,
        Car::class
    );
}

This type of relationship is less common than one-to-one or one-to-many, but it can be useful when your database contains intermediate relationships.

---

5. Has Many Through Relationship

A hasManyThrough relationship allows you to access multiple records through another model.

Example

Country
   ↓
Users
   ↓
Posts

A country has many users, and each user has many posts.

Using hasManyThrough(), you can retrieve posts through the users associated with that country.

public function posts()
{
    return $this->hasManyThrough(
        Post::class,
        User::class
    );
}

This is useful when related data is connected through an intermediate model.

---

6. Polymorphic Relationships

A polymorphic relationship allows one model to belong to different types of models.

This may sound complicated, but the concept is simple.

Real-world example: Comments

Both blog posts and videos can have comments.

Instead of creating separate tables:

post_comments
video_comments

you can use one comments table.

comments
----------------------
id
commentable_id
commentable_type
content

Laravel uses the commentable_id and commentable_type columns to determine which model owns the comment.

The relationship in the Comment model looks like:

public function commentable()
{
    return $this->morphTo();
}

This allows one comments table to work with multiple models.

Common uses of polymorphic relationships

Polymorphic relationships are useful for:

• Comments on posts, videos, or products
• Images belonging to different models
• Likes on posts, comments, or videos
• Reviews for products and services

They help reduce duplicate tables and make your database structure more flexible.

---

Creating Related Records

Eloquent relationships can also make it easier to create related data.

For example, instead of manually assigning the user_id, you can create a post through the user relationship:

$user->posts()->create([
    'title' => 'Laravel Eloquent Relationships',
    'content' => 'A beginner-friendly guide.'
]);

Laravel automatically associates the new post with the user.

This makes your code cleaner and reduces the chance of assigning incorrect foreign keys.

---

Querying Relationships in Laravel

Laravel allows you to query models based on their relationships.

For example, you can find users who have at least one post:

$users = User::has('posts')->get();

You can also add conditions using whereHas().

For example, find users who have published posts:

$users = User::whereHas(
    'posts',
    function ($query) {
        $query->where('status', 'published');
    }
)->get();

This is useful when you need to filter records based on related data.

---

Eager Loading and the N+1 Query Problem

One of the most important concepts when working with Laravel Eloquent relationships is eager loading.

Consider this example:

$posts = Post::all();

foreach ($posts as $post) {
    echo $post->user->name;
}

At first, this code looks completely fine.

However, if there are many posts, Laravel may execute additional queries for every post when accessing the user relationship.

This is known as the N+1 query problem.

For example:

1 query → Get all posts
100 queries → Get users
-----------------------
101 total queries

This can slow down your application.

---

How to Fix the N+1 Problem

Use eager loading with the with() method:

$posts = Post::with('user')->get();

Laravel loads the related users efficiently instead of querying the database repeatedly.

You can also load multiple relationships:

$posts = Post::with([
    'user',
    'comments',
    'tags'
])->get();

Why is eager loading important?

Eager loading helps:

• Reduce database queries
• Improve page performance
• Avoid unnecessary database calls
• Make applications more scalable

For most applications, this is one of the most important Laravel Eloquent performance practices to understand.

---

Lazy Loading vs Eager Loading

The difference is simple.

Lazy Loading

Laravel loads the relationship when you access it.

$post->user;

This is convenient, but using it repeatedly inside loops can cause performance problems.

Eager Loading

Laravel loads the relationship in advance.

Post::with('user')->get();

This is usually better when you already know that you will need the related data.

Quick comparison

Feature	Lazy Loading	Eager Loading
When data loads	When accessed	Before access
Database queries	Can increase	Usually optimized
Best for	Occasional relationships	Lists and collections
Performance	Can cause N+1	Better for large lists

---

Counting Related Records

Sometimes you don’t need the actual relationship data. You only need the number of related records.

For example, instead of loading every comment for every post, use:

Post::withCount('comments')->get();

Laravel adds a comments_count value to each post.

You can then use:

$post->comments_count;

This is useful for showing information such as:

• Number of comments
• Number of orders
• Number of products
• Number of likes

Using relationship counts can be more efficient than loading all related models when you only need the total.

---

Common Mistakes When Using Eloquent Relationships

1. Forgetting the Foreign Key

Make sure your database structure supports the relationship.

For example, if a post belongs to a user, the posts table should normally contain:

user_id

---

2. Creating Incorrect Relationship Types

Always think about the real-world relationship first.

Ask yourself:

Can one record have many related records?

If yes, you may need a hasMany() relationship.

Can both models have multiple connections?

If yes, you may need belongsToMany().

Choosing the correct relationship structure will make your application easier to maintain.

---

3. Ignoring the N+1 Query Problem

Loading relationships inside large loops can create many unnecessary database queries.

When displaying lists, always consider using eager loading:

Post::with('user')->get();

---

4. Loading Too Much Data

Eager loading everything is not always the best solution.

Only load the relationships that your page actually needs.

For example:

Post::with('user')->get();

is better than loading multiple unnecessary relationships for every request.

---

Best Practices for Laravel Eloquent Relationships

Here are some useful best practices:

Use meaningful relationship names

Use names that clearly describe the relationship:

posts()
comments()
orders()
profile()

This makes your code easier to understand.

Follow Laravel naming conventions

Laravel automatically understands many relationships when you follow standard conventions such as:

user_id
post_id
category_id

Following conventions reduces configuration.

Use eager loading for lists

When displaying posts, products, or orders with related data, check for N+1 queries and use eager loading where appropriate.

Keep database relationships consistent

Use proper foreign keys and database constraints when appropriate to maintain data integrity.

Only load what you need

Avoid retrieving large relationships if your page only needs a count or a small piece of information.

---

Frequently Asked Questions

What are Eloquent relationships in Laravel?

Eloquent relationships define how Laravel models are connected to each other. They allow you to work with related database records using simple and expressive PHP methods.

What is the difference between hasOne and belongsTo?

hasOne() is generally defined on the model that owns one related record, while belongsTo() is defined on the model containing the foreign key.

For example, a User hasOne Profile, while a Profile belongsTo a User.

What is the difference between hasMany and belongsToMany?

hasMany() is used when one model owns multiple records through a foreign key.

belongsToMany() is used when both models can have multiple relationships and a pivot table connects them.

What is a pivot table in Laravel?

A pivot table is an intermediate table used to manage many-to-many relationships, such as users and roles.

What is the N+1 query problem?

The N+1 query problem happens when an application executes additional database queries for each record while loading related data. Eager loading with with() helps reduce these unnecessary queries.

When should I use polymorphic relationships?

Use polymorphic relationships when the same model needs to belong to multiple different model types, such as comments belonging to posts, videos, or products.

---

Conclusion

Laravel Eloquent relationships make it much easier to work with connected database tables.

The most important relationships to understand are:

One-to-One
User → Profile

One-to-Many
User → Posts

Many-to-Many
Users ↔ Roles

Polymorphic
Comments → Posts / Videos

For most Laravel applications, you will frequently work with one-to-many and many-to-many relationships. Once you understand how foreign keys, pivot tables, hasMany(), belongsTo(), and eager loading work together, working with relational data becomes much easier.

The key is not to memorize every relationship method. Instead, first understand how your data is connected in the real world, then choose the Eloquent relationship that best represents that connection.

By using the right relationships and avoiding performance issues such as the N+1 query problem, you can build cleaner, faster, and more maintainable Laravel applications.