How to reload/refresh model from database in Laravel?

How to reload/refresh model from database in Laravel?

  1. Blog
  2. 15 November 2026
  3. 4 min read

Stefan Bogdanescu

Founder & Senior Architect

How to Reload/Refresh Model from Database in Laravel

When working with Eloquent models, you often encounter a scenario where you need to discard local state and fetch fresh data directly from the database. In Rails, this is handled by a dedicated reload method on model instances. If you are porting logic from Ruby on Rails or simply prefer that explicit approach, the immediate question is whether Laravel provides an equivalent.

The short answer is no; there is no native reload() method available on Eloquent models in the standard API. While this might initially seem like a missing feature, it stems from a fundamental design difference regarding how data hydration and state management work in PHP compared to Ruby. Understanding why Laravel behaves this way helps you choose the correct pattern for your application.

Why reload Doesn't Exist

In many frameworks, methods like reload are convenient shortcuts that hide the complexity of database interaction. However, in Eloquent, the framework prioritizes explicit control over data flow. When you query a model and assign it to a variable, that variable holds a specific snapshot of the data. If you mutate attributes on that object without saving them to the database, those changes exist only in memory.

Calling a hypothetical reload would force an immediate, expensive database query just to read data you might not need yet. Laravel assumes you are responsible for deciding when to re-query the database. This philosophy prevents accidental performance hits where a developer modifies a model instance and then blindly reloads it, potentially ignoring necessary save operations or transaction boundaries.

The Standard Approach: Re-querying

To achieve the same effect as Rails' user.reload, you must explicitly query the database again using the model's primary key. This is not just a workaround; it is the idiomatic way to handle this situation in Laravel.

If you have a user instance stored in a variable, say $user, and you need its current state from the database, you call find() or fresh(). The choice between these two methods depends on your specific requirements regarding timestamps.

// Option 1: Find by ID (Standard reload behavior)
$reloadedUser = User::find($user->id);

// Option 2: Fresh query (Includes updatedAt/createdAt if they changed)
$freshUser = User::fresh()->find($user->id);

Using fresh() is particularly useful when you suspect that the model's timestamps have been updated by another process or concurrent transaction. If your application relies heavily on optimistic locking via timestamps, fresh() ensures you are working with the absolute latest record, including any changes to the updated_at column. Without it, a standard find might return a model where the internal timestamp check fails if another row has been updated in the same millisecond.

Handling Relationships and Caching

A common pitfall when trying to "reload" a model is assuming that relationships will automatically refresh. If you load a user with their posts attached, and those posts are subsequently deleted or modified by another process, simply re-fetching the user instance might not update the collection of posts if eager loading was used previously.

To ensure a truly fresh state including relationships, you should query the model again with the necessary relationships eager loaded:

// Ensures both the user and their latest relations are fetched from DB
$reloadedUser = User::with(['posts', 'profile'])->find($user->id);

This pattern guarantees that you are not holding onto stale relationship data. It effectively simulates a full page reload for that specific record.

Performance Considerations

While reload sounds efficient because it's a single method call, the underlying operation is a new database query. If you are inside a loop processing thousands of records and need to ensure every attribute is fresh from the DB, batch querying or using eager loading with scopes is often more performant than iterating and calling find() on every single item.

If your use case involves refreshing data after a mass update operation, consider whether you actually need to reload individual models or if you can re-query the specific attributes you care about. Laravel's query builder allows you to select only necessary columns, reducing memory overhead compared to fetching the entire model object.

For more advanced needs regarding model state management and ensuring data consistency in complex transactions, exploring official resources or community discussions on best practices can provide further insight into optimizing Eloquent usage patterns.

Our network