Search in Laravel with Scout in PHP & Laravel Development

Search in Laravel with Scout in PHP & Laravel Development

When your application grows from hundreds of records to millions, a simple database WHERE clause stops being practical. Users expect fast, relevant results the moment they start typing. That's where Search in Laravel with Scout comes in—a powerful abstraction layer that powers full-text search with pluggable drivers, letting you index and query data efficiently without rebuilding your application logic.

Why Scout Matters

Out of the box, Laravel's query builder works fine for exact matches and indexed columns. But full-text search is a different animal. You need fuzzy matching, typo tolerance, relevance ranking, and sub-millisecond response times across millions of records. Scout handles the integration so you focus on what matters: what users want to find.

The real win is that Scout lets you swap drivers without touching application code. Start with database-backed search, move to Meilisearch for better UX, then Algolia for global reach—all with the same interface.

Add Searchable — Automatic Index Synchronization

Scout's Searchable trait automatically keeps your search index in sync with your database. When you create, update, or delete a model, Scout handles the rest.

Start by installing Scout and configuring a driver in your .env:

composer require laravel/scout

# In .env
SCOUT_DRIVER=database
# or meilisearch, typesense, algolia

Add the trait to your model:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Laravel\Scout\Searchable;

class Product extends Model
{
    use Searchable;

    protected $fillable = ['name', 'description', 'sku', 'price'];
}

That's it. Every time you create or update a product, Scout indexes it automatically. When you delete, the index removes it.

For existing data, run the import command to backfill:

php artisan scout:import "App\Models\Product"

In production, we've used this workflow to migrate thousands of products without downtime. The key is running imports during low-traffic windows and monitoring queue performance if you're using async drivers.

Drivers — Choose Your Search Engine

Scout abstracts four main drivers, each suited to different needs:

Database Driver

The database driver uses your existing PostgreSQL or MySQL with a simple full-text search layer. It's lightweight, zero external dependencies, and works great for small-to-medium datasets (under 100K records).

// config/scout.php
'driver' => env('SCOUT_DRIVER', 'database'),

Queries use Laravel's builder, and Scout translates them internally:

$results = Product::search('laptop')->get();

The trade-off: database search doesn't have fuzzy matching or advanced relevance tuning. For e-commerce, we usually outgrow this quickly.

Meilisearch

Meilisearch is a lightweight, self-hosted search engine built in Rust. It gives you typo tolerance, faceting, and ranking out of the box with minimal setup. We've deployed it in Docker on production servers serving millions of queries monthly with sub-50ms latency.

Install Meilisearch (Docker):

docker run -p 7700:7700 getmeili/meilisearch:latest

Configure Scout:

// config/scout.php
'meilisearch' => [
    'host' => env('MEILISEARCH_HOST', 'http://127.0.0.1'),
    'key' => env('MEILISEARCH_KEY', ''),
],

Use it exactly like database:

$results = Product::search('laptpo')->get(); // Typo tolerance built-in

Typesense

Typesense is a modern, open-source alternative similar to Meilisearch but with stronger faceting and analytics. Teams deploying to cloud infrastructure often prefer Typesense because it scales horizontally and has a managed service option.

Algolia

Algolia is the managed, SaaS option. Zero infrastructure, global CDN, and enterprise features like A/B testing. Costs scale with queries, but there's no DevOps burden. Perfect if search infrastructure isn't your core competency.

In practice, we recommend Meilisearch for teams comfortable with infrastructure, Algolia for fast time-to-market.

Queue Indexing — Keep Writes Fast

Here's a common problem: you save a product in your database in 5ms, but Scout synchronously indexes it in Meilisearch, adding 50ms to the request. Your users feel the slowdown.

Scout queues solve this. Indexing happens in the background, keeping your HTTP response fast:

// config/scout.php
'queue' => true,

Now when you save a model, Scout immediately queues an indexing job and returns. Your queue worker indexes in the background:

php artisan queue:work

The sequence looks like:

1. User submits product creation form
2. Model saved to database (5ms)
3. Indexing job queued (1ms)
4. Response sent (6ms total)
5. Queue worker indexes to Meilisearch asynchronously (50ms, invisible to user)

In high-traffic scenarios, we've seen this reduce average response times by 40-60%. The caveat: there's a brief window where the product exists in the database but isn't yet searchable. For most applications, this is acceptable. If you need immediate consistency, disable queuing for critical operations:

Product::withoutSyncingToSearch(function () {
    $product = Product::create($data);
    // Index manually if needed
    $product->searchable();
});

// Or sync immediately (blocking):
$product = Product::create($data);
$product->searchable(); // Force sync

Customize — Control What Gets Indexed

By default, Scout indexes all fillable attributes. That's often wasteful. You might index a product's name and description for search, but not its internal cost or warehouse location.

Override toSearchableArray to control exactly what goes into the index:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Laravel\Scout\Searchable;

class Product extends Model
{
    use Searchable;

    public function toSearchableArray()
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'description' => $this->description,
            'category' => $this->category?->name,
            'sku' => $this->sku,
            // Exclude: price, cost, warehouse_id, etc.
        ];
    }
}

This also lets you denormalize data. Notice category is resolved from a relationship, not a raw column. This flattens your data structure for better search relevance:

// Search now matches both product name and category name
$results = Product::search('electronics')->get();

You can also control which models are searchable:

public function shouldBeSearchable()
{
    return $this->status === 'published' && $this->deleted_at === null;
}

After changing toSearchableArray, re-import:

php artisan scout:flush "App\Models\Product"
php artisan scout:import "App\Models\Product"

Querying with Scout

The search API is minimal and intuitive:

// Basic search
$results = Product::search('wireless headphones')->get();

// With additional filters
$results = Product::search('laptop')
    ->where('status', 'published')
    ->where('price', '<', 1500)
    ->paginate(15);

// Get count
$count = Product::search('phone')->count();

// Raw results (for debugging)
$raw = Product::search('tablet')->raw();

Scout chains naturally with Eloquent, so you can still use with for eager loading relationships, orderBy for secondary sorting, and pagination.

Real-World Example: Product Catalog Search

Let's build a search endpoint for an e-commerce API:

// routes/api.php
Route::get('/products/search', [ProductController::class, 'search']);

// app/Http/Controllers/ProductController.php
public function search(Request $request)
{
    $query = $request->input('q');
    $category = $request->input('category');
    $maxPrice = $request->input('max_price');

    if (!$query || strlen($query) < 2) {
        return response()->json(['products' => []]);
    }

    $results = Product::search($query)
        ->when($category, fn($q) => $q->where('category', $category))
        ->when($maxPrice, fn($q) => $q->where('price', '<', $maxPrice))
        ->with('category', 'reviews')
        ->paginate(20);

    return response()->json($results);
}

This handles real user queries: partial matches, filters, and relationship loading. In production, we add rate limiting and caching to handle spike traffic.

Common Mistakes

• Forgetting to run scout:import on deploy — Your code changes but old data stays indexed. Always import after model changes.
• Indexing too much data — Every field increases index size and memory. Be selective in toSearchableArray.
• Not monitoring queue lag — If indexing jobs queue up faster than workers process them, search results fall behind reality. Set alerts on queue size.
• Mixing database and external drivers without consistency checks — If you switch drivers mid-deployment, validate both are in sync before traffic hits.
• Ignoring soft deletes — Soft-deleted models can leak into search results. Exclude them in shouldBeSearchable.

Key Takeaways

• Add the Searchable trait to keep your index automatically synced with database changes.
• Choose your driver based on scale and infrastructure: database for small datasets, Meilisearch for self-hosted reliability, Algolia for managed simplicity.
• Queue indexing to keep HTTP responses fast while searches stay fresh in the background.
• Use toSearchableArray to control what gets indexed and denormalize data for better relevance.
• Chain Scout with Eloquent filters, relationships, and pagination for flexible search experiences.
• Always re-import after model changes and monitor queue lag in production.