Laravel 5.6 Api - Search,sort and filter on list of data
Stefan Bogdanescu
Founder & Senior Architect · 2026-06-29
# Mastering API Filtering in Laravel: Searching, Sorting, and Filtering Lists of Data
Developing a robust REST API endpoint that allows users to dynamically search, sort, and filter large datasets is a common requirement. As you've encountered, managing multiple input parameters from the frontend and translating them into optimized database queries can be tricky. This post dives deep into how to structure your Laravel applicationâleveraging Eloquent Scopes and the Query Builderâto handle complex request parameters efficiently.
## The Foundation: Eloquent Scopes for Clean Queries
Your current approach using Local Scopes (`scopeOfSearch` and `scopeOfSort`) is excellent. It adheres to the principle of separation of concerns by keeping query logic out of your controller and repository layers, making the code highly reusable and maintainable. This pattern is a cornerstone of efficient data handling in Laravel applications, as highlighted by best practices found on platforms like [laravelcompany.com](https://laravelcompany.com).
The key to optimizing this process lies in how you aggregate these multiple conditions when they are passed together via an API request.
## Optimizing Dynamic Filtering: Search and Sort
Your implementation for searching (`scopeOfSearch`) is already well-structured for partial matching using `LIKE`. To handle searches across multiple columns, as you have done (name, school, email, etc.), the current approach is sound.
For sorting, your `scopeOfSort` correctly builds an array of `orderBy` clauses dynamically. This is the most efficient way to handle dynamic ordering in Laravel:
```php
public function scopeOfSort($query, $sort = [])
{
if ( ! empty($sort) ) {
foreach ( $sort as $column => $direction ) {
// Ensure column names are safe if coming directly from user input
$query->orderBy($column, $direction);
}
} else {
// Default sorting if no sort parameters are provided
$query->orderBy('users.name');
}
return $query;
}
```
This pattern is highly scalable. Any time you need dynamic ordering based on client input, this conditional loop ensures that only requested columns are ordered, preventing SQL injection risks associated with blindly concatenating strings.
## Handling Complex Multi-Criteria Filtering (Status and Date)
The confusion often arises when combining text searches (`q`), sort parameters (`sortby`, `direction`), *and* specific attribute filters (like filtering by `status` or `created_at`).
When the frontend sends multiple filter values, the most optimized way to handle this in your repository function is to check for each parameter individually and apply the corresponding constraint to the base query. This avoids creating massive, nested `WHERE` clauses that become unreadable and difficult to maintain.
Here is how you can refine your `getAllUsers` method to incorporate status and date filtering:
```php
public function getAllUsers($request)
{
$query = User::where('type', '=', 'student'); // Start with the base scope
// 1. Apply Search Filter (Text Search)
$query->ofSearch($request->input('q'));
// 2. Apply Specific Attribute Filters (Status and Date)
if ($status = $request->input('status')) {
$query->where('status', $status);
}
if ($startDate = $request->input('created_at_start')) {
$query->where('created_at', '>=', $startDate);
}
// You could add end dates here as well...
// 3. Apply Sorting
$sort = [];
if ( isset($request->input('sortby')) && isset($request->input('direction')) ) {
$sort[$request->input('sortby')] = $request->input('direction');
}
$query->ofSort($sort);
return $query->paginate($per_page);
}
```
### Why this is Optimal:
1. **Clarity:** Each filter type (search, status, date) has its own dedicated check. If a user only filters by search, no unnecessary `WHERE` clauses are applied.
2. **Efficiency:** By applying filters sequentially, you build the most restrictive query possible before pagination is applied, which minimizes the amount of data transferred from the database.
3. **Reusability:** You keep your complex logic within the scopes and the repository function remains a clean orchestrator.
## Conclusion
By strategically utilizing Eloquent Scopes for complex conditional logic and treating each API request parameter as an independent constraint, you transform a confusing filtering problem into a structured implementation. This approach ensures that your Laravel API remains fast, scalable, and adheres to clean architectural principles. For further insights into building high-performance data layers in Laravel, always refer back to the official documentation and best practices provided by [laravelcompany.com](https://laravelcompany.com).