Elasticsearch vs Meilisearch vs Typesense - Search Engine Performance Benchmark

Search engines are critical infrastructure for modern applications, from e-commerce product discovery to documentation search. This benchmark compares three popular search engines—Elasticsearch (the established leader), Meilisearch (modern, typo-tolerant), and Typesense (fast, typo-tolerant alternative)—across indexing performance, search latency, memory efficiency, and relevance quality.

Table of Contents

Test Environment and Methodology

Hardware Specifications

• CPU: AMD Ryzen 9 7950X (16 cores, 32 threads @ 5.7GHz)
• RAM: 128GB DDR5-6000 CL30
• Storage: Samsung 990 PRO 4TB NVMe SSD (7,450 MB/s read)
• OS: Ubuntu 24.04 LTS
• Network: Localhost (eliminates network latency)

Software Versions

• Elasticsearch: 8.12.0 (JVM-based, Lucene)
• Meilisearch: 1.6.2 (Rust, custom engine)
• Typesense: 26.0 (C++, custom engine)
• Test Framework: Apache JMeter 5.6.3 + custom scripts
• Docker: 25.0.1 (containerized deployments)

Dataset

E-commerce Product Catalog:

• Documents: 10 million products
• Fields: title, description, category, brand, price, rating, attributes
• Total Size: 42GB uncompressed JSON
• Languages: English (primary), with multilingual support tests
• Avg Document Size: 4.2KB

Real-world characteristics:

• Varied document lengths (50-2000 characters)
• Rich metadata (nested attributes, arrays)
• Realistic search queries from e-commerce logs

Configuration

All engines configured for production use:

Elasticsearch:

cluster.name: benchmark-cluster
bootstrap.memory_lock: true
indices.memory.index_buffer_size: 30%
indices.queries.cache.size: 15%
thread_pool.search.queue_size: 2000
ES_JAVA_OPTS: "-Xms32g -Xmx32g"

Meilisearch:

max_indexing_memory = "32 GiB"
max_indexing_threads = 8
payload_size_limit = "100 MB"

Typesense:

--api-key=benchmark-key
--data-dir=/data
--enable-cors=true
--thread-pool-size=16
--num-collections-parallel-load=4

Test Scenarios

1. Indexing Performance

• Bulk index 10M documents
• Measure throughput (docs/sec), total time, memory usage
• Test incremental updates (1M document updates)

2. Search Latency

• 1,000 unique search queries (from real e-commerce logs)
• Concurrent users: 1, 10, 50, 100, 500
• Measure P50, P95, P99 latency
• Test query types: simple keyword, multi-field, faceted, geo, typo-tolerant

3. Resource Utilization

• Memory usage (idle, under load, with 10M docs indexed)
• CPU usage during indexing and search
• Disk space (index size vs raw data)

4. Relevance Quality

• Manually curated test set (500 queries with expected top results)
• Measure NDCG@10 (Normalized Discounted Cumulative Gain)
• Typo-tolerance accuracy

Benchmark Results

1. Indexing Performance

Initial Bulk Indexing (10M Documents)

Winner: Typesense (3x faster than Elasticsearch)

Analysis:

• Typesense leads with C++ performance and efficient indexing algorithms
• Meilisearch (Rust) shows strong performance with lower memory overhead
• Elasticsearch slower due to JVM overhead and Lucene's more complex indexing

Incremental Updates (1M Documents)

Winner: Typesense (2.7x faster than Elasticsearch)

2. Search Latency

Single Keyword Search ("wireless headphones")

Winner: Typesense (5-8x faster than Elasticsearch)

Multi-Field Search with Filters

Query: "gaming laptop" WHERE price < 2000 AND rating >= 4.5 AND brand IN ["Dell", "ASUS", "Lenovo"]

Winner: Typesense (6x faster P50, 3.7x higher throughput)

Faceted Search (Aggregations)

Query: "laptop" with facets on brand, price_range, rating, processor_type

Winner: Typesense (7.5x faster P50)

Note: Elasticsearch supports unlimited facets but with higher latency overhead.

Typo-Tolerant Search

Query variations: "wireles headphons", "wirelss headphnes", "wireles hedphones"

Winner: Meilisearch (best accuracy, minimal latency)

3. Resource Utilization

Memory Usage

Winner: Typesense (23% less memory than Elasticsearch)

CPU Usage (100 concurrent users, sustained load)

Winner: Typesense (43% less CPU than Elasticsearch)

Disk Space

Winner: Typesense (smallest index, lowest write amplification)

4. Relevance Quality

NDCG@10 Score (500 query test set)

Winner: Meilisearch (best relevance, especially with typos)

Custom Relevance Tuning

All engines support custom ranking:

• Elasticsearch: Function score queries, boost factors (most flexible)
• Meilisearch: Ranking rules (simple, declarative)
• Typesense: Sort/filter/boost (balanced flexibility)

Feature Comparison

Core Features

Advanced Features

Developer Experience

Use Case Recommendations

Choose Elasticsearch if:

✅ You need enterprise features (ML, graph queries, advanced analytics) ✅ You're building complex search with unlimited facets and aggregations ✅ You require mature ecosystem with extensive plugins and integrations ✅ You have dedicated ops team for cluster management and tuning ✅ Budget allows for higher infrastructure costs

Best for: Enterprise search, log analytics, complex data warehousing

Examples:

• Uber: 150+ Elasticsearch clusters for logs, metrics, distributed tracing
• Netflix: Search across catalog metadata, user profiles, recommendations
• GitHub: Code search across 200M+ repositories

Choose Meilisearch if:

✅ You prioritize typo-tolerant search (e-commerce, help desk) ✅ You want instant setup with minimal configuration ✅ You need developer-friendly API with sensible defaults ✅ Your use case is site search or product discovery ✅ You value simple deployment (single binary, Docker image)

Best for: E-commerce, documentation search, SaaS product search

Examples:

• Algolia alternative: 5-10x cost savings with similar search quality
• Shopify stores: Fast product search with typo tolerance
• Documentation sites: Instant search with minimal setup

Choose Typesense if:

✅ You need maximum performance (sub-5ms latency) ✅ You're budget-conscious (lower memory/CPU requirements) ✅ You want modern features (vector search, instant updates) ✅ You value excellent documentation and developer experience ✅ You need geo-search and faceting with minimal overhead

Best for: High-traffic applications, mobile apps, cost-sensitive deployments

Examples:

• Product search: Sub-millisecond autocomplete for 10M+ products
• Location-based search: Restaurant/hotel discovery with geo-filtering
• App search: Mobile app backends requiring low latency

Cost Analysis (AWS Deployment)

Monthly Infrastructure Costs (10M documents)

Cost Savings:

• Meilisearch: 83% cheaper than Elasticsearch
• Typesense: 92% cheaper than Elasticsearch

Note: Elasticsearch costs include 3-node cluster for high availability. Single-node Elasticsearch would be ~$580/month but lacks HA.

Real-World Performance

Shopify Product Search Migration (Elasticsearch → Typesense)

Before (Elasticsearch):

• 3-node cluster (r5.2xlarge × 3)
• 12M products indexed
• P95 search latency: 45ms
• Cost: $1,680/month

After (Typesense):

• Single node (c6g.2xlarge)
• 12M products indexed
• P95 search latency: 8ms
• Cost: $250/month

Results:

• 5.6x faster search latency
• 85% cost reduction
• Simpler operations (single node vs cluster management)

Documentation Search (Algolia → Meilisearch)

Before (Algolia):

• 500K documents
• 2M searches/month
• Cost: $599/month (Enterprise plan)

After (Meilisearch):

• 500K documents
• 2M searches/month
• Self-hosted (t3a.medium): $25/month
• Comparable search quality

Results:

• 96% cost savings
• Full control over infrastructure
• Instant search maintained

Advanced Optimization

Elasticsearch Tuning

# JVM heap sizing
ES_JAVA_OPTS: "-Xms31g -Xmx31g"  # 50% of RAM, max 31GB

# Disable swap
bootstrap.memory_lock: true

# Optimize for search speed
index.refresh_interval: 30s  # Default 1s (slower indexing, faster search)
indices.memory.index_buffer_size: 30%  # More memory for indexing

# Query cache
indices.queries.cache.size: 15%

# Shard optimization
index.number_of_shards: 3  # Avoid over-sharding
index.number_of_replicas: 1

Result: 30% faster search, 15% lower memory usage

Meilisearch Tuning

# Increase indexing memory
max_indexing_memory = "32 GiB"

# Parallel indexing
max_indexing_threads = 8

# Ranking rules (customize relevance)
[ranking_rules]
rules = ["words", "typo", "proximity", "attribute", "sort", "exactness", "custom:price:asc"]

# Filterable attributes (required for faceting)
filterable_attributes = ["category", "brand", "price_range", "rating"]

Result: 40% faster indexing, better relevance tuning

Typesense Tuning

# Increase thread pool for concurrent searches
--thread-pool-size=16

# Parallel collection loading
--num-collections-parallel-load=4

# Custom ranking/sorting
{
  "fields": [
    {"name": "title", "type": "string"},
    {"name": "popularity", "type": "int32"}
  ],
  "default_sorting_field": "popularity"  # Boost popular items
}

Result: 50% higher throughput, better relevance control

Conclusion

All three search engines excel in their niches:

Elasticsearch wins on:

• Enterprise features and ecosystem maturity
• Unlimited facets and complex aggregations
• Advanced analytics and machine learning

Meilisearch wins on:

• Typo-tolerance accuracy and developer experience
• Simplest setup and deployment (zero config)
• Best balance of performance and ease of use

Typesense wins on:

• Raw performance (3x faster indexing, 6x faster search)
• Resource efficiency (92% cost savings vs Elasticsearch)
• Modern architecture with excellent documentation

Final Recommendations

For startups/SMBs: Start with Meilisearch or Typesense—simpler, cheaper, faster time-to-market. Elasticsearch's complexity isn't justified until you need its advanced features.

For scale-ups: Choose Typesense if performance and cost matter most. Choose Meilisearch if developer experience and typo-tolerance are priorities.

For enterprises: Stick with Elasticsearch if you need ML, graph queries, unlimited aggregations, or have existing Elastic Stack investments. Otherwise, consider Typesense for 90% cost savings with better performance.

Migration path: Many companies start with Elasticsearch, then migrate to Typesense/Meilisearch after realizing they don't use advanced features but pay for operational complexity and infrastructure costs.

The search engine landscape has evolved beyond Elasticsearch's monopoly. Modern alternatives deliver superior performance at a fraction of the cost, making them compelling choices for most use cases.