Eloquent Optimization: withExists and withCount Beyond N+1 | Mohamed Said [Skip to content](#main) [ ![](https://cdn.msaied.com/01KT78WE565VEMM3PSNQAAB0MH.png) Mohamed SaidLaravel Backend Engineer ](https://www.msaied.com/public) - [Home](https://www.msaied.com/public) - [Projects](https://www.msaied.com/public/projects) - [Articles](https://www.msaied.com/public/articles) - [Certificates](https://www.msaied.com/public/certificates) - [About](https://www.msaied.com/public#about) [ Contact](https://www.msaied.com/public#contact) Menu Menu ---- Close - [HomeStart here](https://www.msaied.com/public) - [ProjectsCase studies](https://www.msaied.com/public/projects) - [ArticlesEngineering notes](https://www.msaied.com/public/articles) - [CertificatesCredentials](https://www.msaied.com/public/certificates) - [AboutHow I work](https://www.msaied.com/public#about) - [ContactGet in touch](https://www.msaied.com/public#contact) [Start a conversation](https://www.msaied.com/public#contact) [WhatsApp](https://wa.me/201094619204) [Email](mailto:hello@msaied.com) 1. [Home](https://www.msaied.com/public) 2. / 3. [Articles](https://www.msaied.com/public/articles) 4. / 5. Optimizing Eloquent Queries: Beyond N+1 with `withExists` and `withCount` Optimizing Eloquent Queries: Beyond N+1 with `withExists` and `withCount` ========================================================================== N+1 query issues are a common performance bottleneck in Laravel applications. While `with()` is the go-to solution for eager loading relationships, many developers overlook the power of `withExists()` and `withCount()` for specific scenarios. This article dives into practical applications of these lesser-used Eloquent methods to significantly reduce query load and improve application responsiveness, especially when dealing with conditional rendering or aggregate data. ![](https://cdn.msaied.com/01M22N44A70A5MC2S599JP0MPH.webp) [Mohamed Said](https://www.msaied.com/public#person) Published 14 Jun 2026 · Updated 14 Jun 2026 · 4 min read ShareCopy linkCopied ![Optimizing Eloquent Queries: Beyond N+1 with `withExists` and `withCount`](https://cdn.msaied.com/160/89eca7b3d4a7f19692354a7621a64bb3.png) On this page +1. [Optimizing Eloquent Queries: Beyond N+1 with withExists and withCount](#optimizing-eloquent-queries-beyond-n1-with-codewithexistscode-and-codewithcountcode) 2. [The N+1 Problem Revisited](#the-n1-problem-revisited) 3. [Introducing withExists()](#introducing-codewithexistscode) 4. [Leveraging withCount()](#leveraging-codewithcountcode) 5. [Combining for Complex Scenarios](#combining-for-complex-scenarios) 6. [Takeaways:](#takeaways) Optimizing Eloquent Queries: Beyond N+1 with `withExists` and `withCount` ------------------------------------------------------------------------- N+1 query problems are a perennial concern in Laravel applications. The typical solution, `with()`, effectively eager loads related models, preventing a cascade of individual queries. However, `with()` is not always the most efficient tool, particularly when you only need to know *if* a relationship exists or *how many* related records there are, rather than the full related data itself. This article explores `withExists()` and `withCount()`, two powerful Eloquent methods that can drastically optimize query performance in specific, common scenarios. ### The N+1 Problem Revisited Consider a `Post` model with many `Comment` models. If you want to display a list of posts and indicate whether each post has *any* comments, a naive approach might look like this: ```php $posts = Post::all(); foreach ($posts as $post) { if ($post->comments->isNotEmpty()) { // Render 'Has Comments' badge } } ``` This code executes `Post::all()` (1 query) and then `SELECT * FROM comments WHERE post_id = ?` for *each* post (N queries), leading to N+1 queries. Eager loading with `with('comments')` would fetch all comments for all posts in a single additional query, but it still pulls potentially large datasets of comment bodies that aren't needed. ### Introducing `withExists()` When you only need to check for the *existence* of related records, `withExists()` is your ally. It adds a boolean attribute to each parent model, indicating whether the specified relationship has any associated records. This is achieved with a subquery, often more efficient than fetching all related data. Let's refactor the previous example: ```php $posts = Post::withExists('comments')->get(); foreach ($posts as $post) { if ($post->comments_exists) { // Render 'Has Comments' badge } } ``` This executes two queries: one for `posts` and one for the `comments_exists` subquery. The `comments_exists` attribute is automatically appended to each `Post` model. This is significantly more efficient than eager loading all comment data when only existence is required. You can also alias the existence column: ```php $posts = Post::withExists('comments as has_comments')->get(); // ... $post->has_comments ... ``` ### Leveraging `withCount()` Similarly, when you need to display the *number* of related records, `withCount()` is the optimal choice. It adds a `_count` attribute to the parent model, containing the count of related records, again via a subquery. Example: Displaying the number of comments for each post. ```php $posts = Post::withCount('comments')->get(); foreach ($posts as $post) { echo "Post: {$post->title}, Comments: {$post->comments_count}\n"; } ``` Like `withExists()`, this results in two efficient queries. You can also apply constraints to the count: ```php $posts = Post::withCount(['comments' => function ($query) { $query->where('approved', true); }])->get(); // $post->comments_count will now reflect only approved comments ``` And, of course, alias the count column: ```php $posts = Post::withCount('comments as total_comments')->get(); // ... $post->total_comments ... ``` ### Combining for Complex Scenarios You can combine `withExists()`, `withCount()`, and even `with()` for scenarios where you need both aggregate data and specific related models. ```php $posts = Post::withExists('comments as has_comments') ->withCount('likes') ->with('author') // Eager load the author relationship ->get(); foreach ($posts as $post) { echo "Post: {$post->title} (by {$post->author->name})\n"; echo " Has Comments: " . ($post->has_comments ? 'Yes' : 'No') . "\n"; echo " Likes: {$post->likes_count}\n"; } ``` This approach ensures that only the necessary data is fetched, leading to leaner queries and faster response times. Always profile your queries (e.g., with Laravel Debugbar or `DB::listen()`) to confirm the performance benefits in your specific context. ### Takeaways: - `withExists()` is ideal for checking the presence of related records without fetching their data. - `withCount()` efficiently retrieves the number of related records. - Both methods generate subqueries, often more performant than full eager loading when only existence or count is needed. - Alias the generated attributes for clarity and to avoid naming conflicts. - Combine these methods with `with()` when you need a mix of aggregate data and full related models. - Always profile your database interactions to validate optimization efforts. - [Laravel](https://www.msaied.com/public/articles?search=Laravel) - [Eloquent](https://www.msaied.com/public/articles?search=Eloquent) - [Performance](https://www.msaied.com/public/articles?search=Performance) - [Optimization](https://www.msaied.com/public/articles?search=Optimization) - [N+1](https://www.msaied.com/public/articles?search=N%2B1) - [Database](https://www.msaied.com/public/articles?search=Database) Frequently asked questions --------------------------- When should I use `withExists()` instead of `with('relationship')->has('relationship')`?`withExists()` is generally more efficient. `with('relationship')->has('relationship')` would first eager load the relationship (potentially fetching all data) and then filter, whereas `withExists()` directly uses a subquery to check for existence without fetching the related data itself, leading to fewer columns and rows transferred from the database. Can I use `withCount()` with multiple relationships or custom conditions?Yes, `withCount()` accepts an array of relationships, and each can have a closure to apply custom query constraints. For example: `Post::withCount(\['comments', 'likes' => fn ($q) => $q->where('active', true)\])->get();` ![Mohamed Said](https://cdn.msaied.com/01M22N44A70A5MC2S599JP0MPH.webp)About the author ---------------- [Mohamed Said](https://www.msaied.com/public#person)Senior Backend Engineer specializing in Laravel, scalable SaaS platforms, APIs, and cloud infrastructure. I build secure, high-performance web applications that help businesses grow. [About](https://www.msaied.com/public#about) [GitHub ↗](https://github.com/EG-Mohamed) [LinkedIn ↗](https://www.linkedin.com/in/msaiedm/) [WhatsApp ↗](https://wa.me/201094619204) [Email Address ↗](mailto:hello@msaied.com) [My CV ↗](https://drive.google.com/file/u/0/d/1MF20IPRJyzfy32mhEutjL5EpSls0w2Q8/view) [Previous articleClaude Code Repository Updates: Version v2.1.177 Released](https://www.msaied.com/public/articles/claude-code-repository-updates-version-v21177-released) [Next articleOptimizing Laravel Queues: Leveraging `retryUntil` for Robust Job Handling](https://www.msaied.com/public/articles/optimizing-laravel-queues-leveraging-retryuntil-for-robust-job-handling) On this page ------------- 1. [Optimizing Eloquent Queries: Beyond N+1 with withExists and withCount](#optimizing-eloquent-queries-beyond-n1-with-codewithexistscode-and-codewithcountcode) 2. [The N+1 Problem Revisited](#the-n1-problem-revisited) 3. [Introducing withExists()](#introducing-codewithexistscode) 4. [Leveraging withCount()](#leveraging-codewithcountcode) 5. [Combining for Complex Scenarios](#combining-for-complex-scenarios) 6. [Takeaways:](#takeaways) ### Have a technical challenge? Tell me what you’re building. I reply within two working days. [Start a conversation](https://www.msaied.com/public#contact) Related articles ----------------- [ ![](https://cdn.msaied.com/740/cce86edc21eddcbdd2f2454fadaf9c70.png) · 3 min read### The Pipeline Pattern in Laravel: Custom Pipelines Beyond Middleware 5 Oct 2026 ](https://www.msaied.com/public/articles/the-pipeline-pattern-in-laravel-custom-pipelines-beyond-middleware-1) [ ![](https://cdn.msaied.com/739/2d6897fdcdcf090613f96f72a64b8a78.png) · 4 min read### MySQL Full-Text Search in Laravel: Indexes, Relevance Scoring, and Boolean Mode 4 Oct 2026 ](https://www.msaied.com/public/articles/mysql-full-text-search-in-laravel-indexes-relevance-scoring-and-boolean-mode) [ ![](https://cdn.msaied.com/738/073696a3fefe18bec825beec5ac658f5.png) · 4 min read### Laravel Queue Rate-Limited Middleware: Throttling Jobs Without Losing Work 4 Oct 2026 ](https://www.msaied.com/public/articles/laravel-queue-rate-limited-middleware-throttling-jobs-without-losing-work) Have a technical challenge? ---------------------------- Tell me what you’re building. I reply within two working days. [Discuss your project ↗](https://www.msaied.com/public#contact) © 2026 Mohamed Said · Built with Laravel, meant to last.Senior Backend Engineer specializing in Laravel, scalable SaaS platforms, APIs, and cloud infrastructure. I build secure, high-performance web applications that help businesses grow. - [Home](https://www.msaied.com/public) - [Articles](https://www.msaied.com/public/articles) - [Certificates](https://www.msaied.com/public/certificates) - [GitHub](https://github.com/EG-Mohamed) - [LinkedIn](https://www.linkedin.com/in/msaiedm/) - [WhatsApp](https://wa.me/201094619204) - [Email Address](mailto:hello@msaied.com) - [My CV](https://drive.google.com/file/u/0/d/1MF20IPRJyzfy32mhEutjL5EpSls0w2Q8/view) - [Sitemap](https://www.msaied.com/public/sitemap.xml)