Meilisearch vs Typesense vs Algolia for Shopify Hydrogen (2026)

The headless commerce search stack has converged on three names in 2026: Meilisearch, Typesense, and Algolia. Each one has a real production user base, each one wins on a different axis, and each one fits a specific Hydrogen build pattern. We have shipped Shopify Plus headless storefronts with all three engines over the last 18 months. This is the comparison from the integration side, not the marketing side.

Comparison Table: Search Engines for Shopify Hydrogen (June 2026)

Dimension	Meilisearch v1.18	Typesense v28	Algolia
License	MIT	GPLv3	Proprietary
Hosting	Self-hosted or Meilisearch Cloud	Self-hosted or Typesense Cloud	Managed only
Index format	LMDB-backed, on-disk	RocksDB, on-disk	Proprietary, in-memory tier
Indexing throughput	8K docs/sec (single node)	12K docs/sec (single node)	25K docs/sec (managed cluster)
Faceted search	Yes, supports filterable attributes	Yes, full-featured	Yes, most mature implementation
Typo tolerance	Native, configurable	Native, configurable	Native, most refined
Vector search	Yes, hybrid with BM25 (v1.16+)	Yes, hybrid with BM25 (v28+)	Yes (Algolia NeuralSearch)
Distributed cluster	Experimental (v1.17 prologue)	Yes, multi-node	Yes, managed multi-region
OpenAI embeddings integration	Native	Native	Native
Hydrogen integration package	Community (@meilisearch/hydrogen)	Community (@typesense/hydrogen-search)	Official (@algolia/shopify)
Pricing at 100K SKU, 5M searches/mo	$79/mo (Cloud) or self-hosted	$99/mo (Cloud) or self-hosted	~$800/mo (Build tier)
Pricing at 1M SKU, 50M searches/mo	$499/mo (Cloud) or self-hosted	$599/mo (Cloud) or self-hosted	~$8,500/mo (Premium tier)

The pricing column is where the conversation usually ends. It should not. The other columns matter more for whether the engine fits your specific Hydrogen build.

Where Each Engine Won in Our Hydrogen Builds

We have shipped three production Hydrogen storefronts in the last 18 months using these engines:

A skincare brand on Shopify Plus with 1,800 SKUs and 800K monthly searches. Shipped on Meilisearch self-hosted on a single Hetzner box. Total search infrastructure cost: about $60 per month.

A multi-brand apparel storefront on Shopify Plus with 45,000 SKUs and 8M monthly searches. Shipped on Typesense Cloud. Total search infrastructure cost: about $400 per month at our usage.

A B2B industrial parts catalog on Shopify Plus with 1.2M SKUs, complex faceting requirements (12 simultaneously filterable attributes per query), and 25M monthly searches. Shipped on Algolia. Total search infrastructure cost: about $5,200 per month.

The pattern is clear. The right engine depends on the catalog size, the faceting complexity, and the search volume, not on engine quality in the abstract.

Indexing from Shopify into Each Engine

Shopify Plus exposes product, variant, and metafield data through the Admin GraphQL API and webhook events. The indexing pipeline pattern is the same across all three engines: subscribe to products/update, products/create, and products/delete webhooks; transform the payload into the engine's document schema; push to the engine.

The integration details differ:

Meilisearch accepts documents in flat JSON. The schema is implicit; the engine infers types from the first document. The indexing latency is around 200ms per batch of 100 documents on a single node. Re-indexing the full catalog of 50K products takes about 90 seconds.

import { MeiliSearch } from 'meilisearch'

const client = new MeiliSearch({ host: 'http://localhost:7700', apiKey: process.env.MEILI_KEY })
const index = client.index('products')

async function handleProductUpdate(product: ShopifyProduct) {
  await index.addDocuments([{
    id: product.id,
    title: product.title,
    description: product.descriptionHtml,
    price: product.priceRange.minVariantPrice.amount,
    vendor: product.vendor,
    tags: product.tags,
    available: product.availableForSale,
  }])
}

Typesense requires an explicit schema. This is a real ergonomic difference: you get strong typing and validation at the cost of a schema migration step when you add a facet. Re-indexing 50K products takes about 60 seconds. The schema-first approach pays off when your catalog grows past 100K SKUs because query plans are more predictable.

Algolia uses an implicit schema like Meilisearch but exposes more attribute-level configuration (searchable, filterable, ranking). Re-indexing 50K products on the managed cluster takes about 30 seconds. Algolia's batch indexing API has the best ergonomics of the three for large initial loads.

Faceted Search at Hydrogen Scale

Faceted search is where the engines diverge in production behavior. A typical Hydrogen storefront filters by category, price range, color, size, vendor, and a few brand-specific attributes (skin type, fit, season). For a query like "anti-aging serum under $50 in stock" with five active facets across a 100K product catalog, the latency distribution matters more than the median.

Meilisearch handles this well up to about 200K documents on a single node. Beyond that, complex filter combinations start to show tail latency above 200ms. The engine does not yet have native sharding (the v1.17 prologue is experimental and not production-ready as of June 2026). For catalogs above 200K SKUs with heavy faceting, Meilisearch is not yet the right answer.

Typesense handles this well up to about 1M documents per node and supports multi-node clusters for larger catalogs. The query planner is more sophisticated than Meilisearch's, and complex filter combinations stay under 80ms p99 in our 45K SKU production deployment.

Algolia has the best tail latency at any scale. Their query planner has had 12+ years of optimization specifically for faceted search, and the managed infrastructure absorbs traffic spikes without re-tuning. For catalogs above 500K SKUs or for storefronts with extreme faceting complexity, Algolia is the safest pick.

Vector and Hybrid Search

All three engines now support vector search, and all three support hybrid search (combining BM25 lexical with vector semantic scoring). The implementations matured in late 2025 and early 2026.

Meilisearch v1.16 introduced vector search with native OpenAI embedding integration. You configure an embedder in the index settings, and the engine handles embedding generation on document insert. Hybrid search uses a configurable lexical-to-semantic ratio.

Typesense v28 ships similar hybrid search with built-in support for OpenAI, Cohere, and self-hosted embedding endpoints. The hybrid scoring is slightly more transparent (the engine returns lexical and semantic scores separately).

Algolia NeuralSearch is the most mature implementation, but it is a separate paid tier on top of the search infrastructure. For Hydrogen builds where neural search is part of the merchandising story (semantic product discovery, natural language queries), it adds about $1,500 per month to the Algolia bill at moderate scale.

For most Shopify Hydrogen builds, hybrid search on Meilisearch or Typesense is sufficient. The neural query understanding that Algolia offers is differentiated, but the use cases that need it are narrower than the marketing suggests.

Hydrogen Integration Patterns

The Hydrogen integration story differs across the three engines.

Algolia ships the most mature Hydrogen integration: an official @algolia/shopify package, a React InstantSearch library, server-side rendering helpers, and pre-built components for facets, refinement lists, and pagination. You can ship a working search UI in about 200 lines of code.

Typesense has a community-maintained @typesense/hydrogen-search package and the typesense-instantsearch-adapter that lets you use the Algolia InstantSearch components against a Typesense backend. The integration takes about 400 lines of code but the developer experience is clean.

Meilisearch has the lightest integration story: the meilisearch JavaScript client and a community Hydrogen example. You write the UI components yourself. For a custom search experience, this is fine. For a fast time-to-market with pre-built UI, Algolia wins.

Pricing at Scale: Where the Numbers Actually Land

Self-hosted Meilisearch or Typesense on a Hetzner CCX23 ($60/mo, 8 vCPU, 32GB RAM, NVMe) handles up to 200K SKUs and 5M monthly searches comfortably. Add a load balancer and a second instance for failover, and you are at $140 per month all-in.

Managed Typesense Cloud at the same volume costs about $400 per month. The managed offering buys you the upgrade path to multi-region and the operational hands-off-ness; if you do not need either, the self-hosted economics are unbeatable.

Algolia at 5M monthly searches across 100K SKUs starts at around $800 per month on the Build tier and scales linearly. At 50M monthly searches across 1M SKUs, you are looking at $8,500 per month on Premium. The price buys you the SLA, the operational maturity, and the time saved on integration.

For a venture-backed DTC brand that needs to ship in two weeks and does not have a search engineering function, Algolia's pricing is reasonable. For an engineering-led team with existing infrastructure operations, the self-hosted engines are 10x to 20x cheaper at scale.

When This Applies to Your Stack

Choose Meilisearch if your catalog is under 200K SKUs, your faceting is moderate (under 8 simultaneously filterable attributes), and you want the lightest operational footprint. The self-hosted economics are excellent and the engine is genuinely production-ready at this scale.

Choose Typesense if your catalog is 200K to 1M SKUs, you need a real multi-node cluster, or you want the best self-hosted ergonomics for hybrid search. The schema-first design pays off as your catalog grows.

Choose Algolia if your catalog exceeds 1M SKUs, your faceting is complex (more than 8 simultaneously filterable attributes), or your team needs the fastest path to a polished search UI. The pricing is real but so is the operational maturity.

For most mid-market Hydrogen builds (50K to 500K SKUs, moderate faceting, 1M to 20M monthly searches), Typesense is the most defensible default. It is the right balance of cost, scale headroom, and operational reasonableness for this band.

Talk to Us About Headless Commerce Search

We have shipped Shopify Plus Hydrogen storefronts on all three of these engines for brands ranging from small DTC to enterprise B2B catalogs. If you are picking a search engine, sizing a multi-region deployment, or planning a migration off Algolia for cost reasons, we can help you evaluate the trade-offs against your actual catalog and search patterns.

FAQ

Can I migrate from Algolia to Meilisearch or Typesense without rewriting my frontend?

Partially. Typesense's InstantSearch adapter lets you reuse most of the Algolia React components with minimal changes (typically a few hours of work for a typical Hydrogen build). Meilisearch does not have a comparable adapter; you rewrite the UI. For the cost savings at scale, the rewrite is usually justified, but plan for it.

How does Shopify's native search compare?

Shopify's storefront search is fine for low-volume DTC stores with simple catalogs. For headless Hydrogen builds, it does not support the faceting depth or query control that any of these dedicated engines provide. If you have moved to Hydrogen, you have already implicitly decided to run a separate search infrastructure.

What about Elasticsearch or OpenSearch for Shopify Hydrogen?

Both are credible at very large scale (10M+ SKUs) and for teams that already operate an Elasticsearch cluster for other reasons. The operational overhead is meaningfully higher than any of the three engines covered here. We covered the Elasticsearch story in detail in a separate post; the short version is that for most Shopify Hydrogen builds it is overkill.

Does any of these handle Shopify's metafield-heavy catalogs natively?

Meilisearch and Typesense both let you flatten metafields into searchable or filterable attributes at index time. Algolia does the same with attribute configuration. The schema management overhead is similar across the three; the determining factor is how often your metafield structure changes (each change requires a re-index).