)
}
function PackageHit({ hit }: { hit: any }) {
return (
{hit.name}
{hit.description}
{hit.tags?.map((tag: string) => (
{tag}
))}
)
}
```
### Analytics and A/B testing
```typescript
import algoliasearch from "algoliasearch"
const client = algoliasearch(appId, adminKey)
// Enable analytics:
const index = client.initIndex("packages")
await index.setSettings({
enablePersonalization: true,
enableRules: true,
})
// Query rules (merchandising):
await index.saveRule({
objectID: "promote-react",
conditions: [{
anchoring: "contains",
pattern: "ui library",
}],
consequence: {
promote: [{
objectID: "1", // react
position: 0,
}],
},
})
// A/B test:
const response = await client.addABTest({
name: "ranking-test",
variants: [
{ index: "packages", trafficPercentage: 50, description: "Current" },
{ index: "packages_v2", trafficPercentage: 50, description: "New ranking" },
],
endAt: "2026-04-01T00:00:00Z",
})
```
---
## Feature Comparison
| Feature | Meilisearch | Typesense | Algolia |
|---------|------------|----------|---------|
| Open-source | ✅ | ✅ | ❌ (proprietary) |
| Self-hosted | ✅ | ✅ | ❌ (cloud only) |
| Cloud offering | Meilisearch Cloud | Typesense Cloud | ✅ (primary) |
| Typo tolerance | ✅ | ✅ | ✅ |
| Faceted search | ✅ | ✅ | ✅ |
| Geo search | ✅ | ✅ | ✅ |
| Vector search | ✅ (experimental) | ✅ | ✅ (NeuralSearch) |
| InstantSearch UI | ✅ (via adapter) | ✅ (via adapter) | ✅ (native) |
| Analytics | ❌ | ❌ | ✅ |
| A/B testing | ❌ | ❌ | ✅ |
| Query rules | ❌ | ✅ (overrides) | ✅ |
| Multi-tenancy | ✅ (tenant tokens) | ✅ (scoped keys) | ✅ (API keys) |
| Written in | Rust | C++ | C++ |
| Indexing speed | Fast | Very fast | Fast |
| Search latency | ~1-5ms | ~0.5-2ms | ~1-5ms |
| Free tier | Self-hosted | Self-hosted | 10K searches/mo |
---
## When to Use Each
**Use Meilisearch if:**
- Want easy-to-setup open-source search
- Need instant search with great developer experience
- Building search for small to medium datasets
- Want self-hosted search with minimal configuration
**Use Typesense if:**
- Need the fastest open-source search engine
- Want vector search for semantic/AI-powered search
- Need geo search capabilities
- Building search for large datasets with strict latency requirements
**Use Algolia if:**
- Want fully managed search-as-a-service
- Need analytics, A/B testing, and query rules
- Building commercial search for e-commerce or SaaS
- Want the richest InstantSearch UI component library
---
## Methodology
Download data from npm registry (weekly average, February 2026). Feature comparison based on Meilisearch v1.x, Typesense v0.25.x/v27.x, and Algolia v4.x/v5.x.
## Indexing Strategy and Real-Time Updates
How each engine handles index updates directly affects the search experience for applications with frequently changing data. Meilisearch uses an optimistic indexing strategy — documents added via `addDocuments()` are available for search within a few hundred milliseconds for small batches. The index update is performed asynchronously and returns a task ID you can poll to confirm completion. For applications that update documents frequently (e-commerce inventory, news articles, npm package metadata), this async approach means search results can be slightly stale. Meilisearch's task queue ensures updates are eventually consistent, and for most search use cases, sub-second staleness is acceptable.
Typesense's indexing is similarly asynchronous but exposes more direct control over when changes are committed. Its `importDocuments` endpoint with `action: "upsert"` efficiently handles bulk updates, and the strict schema definition means Typesense validates documents against the collection schema at index time — you'll get an error immediately if a document doesn't match the expected types, rather than discovering the mismatch when search returns malformed results. For search applications where data quality is critical, Typesense's schema enforcement is a meaningful operational advantage.
Algolia processes index updates synchronously from the API client's perspective — `saveObjects` returns only after the index is updated and searchable. This makes it easier to reason about consistency: after the API call returns successfully, the documents are immediately searchable with no polling required. For high-volume update scenarios (price changes on thousands of products), Algolia's batch operations can handle thousands of documents in a single API call, and their infrastructure is designed for this use pattern at scale.
## Tenant Isolation and Multi-Tenant Search
Applications that serve multiple customers from a single index — SaaS platforms, marketplaces, multi-team tools — need to ensure one tenant can't see another's data in search results. All three engines support this through tenant tokens or scoped API keys, but the implementation patterns differ.
Meilisearch's tenant tokens embed filter conditions into a short-lived JWT. When your server generates a tenant token for user X, you include a filter clause like `tenantId = "X"` in the token. The search SDK uses this token for all searches, and Meilisearch enforces the filter server-side — the user cannot remove it. This is secure without requiring per-tenant indexes.
Typesense achieves the same via scoped API keys that can embed filter conditions: `filter_by: "tenant_id:=user_123"`. The scoped key is generated server-side, passed to the client, and Typesense enforces the filter on every search using that key. This is the same security model as Meilisearch's tenant tokens but without the JWT structure.
Algolia uses secured API keys — API keys generated server-side with embedded filter restrictions. A secured key with `filters: "tenantId:user123"` ensures all searches using that key automatically apply the filter. Algolia's advantage is that generating and revoking secured keys can be done programmatically via their API, and the key expiry can be set at generation time without maintaining a key-to-tenant mapping on your server.
For high-scale multi-tenant deployments (thousands of tenants), all three engines support per-tenant indexes as an alternative — creating a separate index per tenant provides complete isolation and allows per-tenant configuration but increases operational complexity. Per-tenant indexes are generally only appropriate when tenants have meaningfully different search configuration needs (custom ranking, different searchable attributes).
## TypeScript SDK Quality and Developer Experience
The quality of the JavaScript/TypeScript SDK significantly affects day-to-day development productivity. Meilisearch's `meilisearch` npm package ships comprehensive TypeScript definitions that cover the full API surface. The `MeiliSearch` client class, index operations, search parameters, and response types are all fully typed. A particularly useful detail is that the `search()` method is generic — `index.search(query, params)` returns `SearchResponse` where `hits` is `PackageDocument[]`, giving type-safe access to your document fields without casting.
Typesense's TypeScript SDK is similarly complete. The `SearchResponse` type is generic over the document type, and the collection schema definition uses TypeScript types to ensure your field definitions match your document structure at compile time. The `TypesenseInstantsearchAdapter` — used to connect Typesense to the InstantSearch UI library — also ships TypeScript definitions, enabling type-safe configuration of the search adapter without runtime surprises.
## Performance Tuning and Search Relevance Configuration
Out-of-the-box relevance is one dimension; tuning relevance for your specific data and user behavior is another. Meilisearch exposes six ranking rules in a configurable order: `words`, `typo`, `proximity`, `attribute`, `sort`, and `exactness`. The order determines priority — if two documents match the query equally on `words`, the `typo` rule breaks the tie by favoring the document with fewer typos in the matching terms. Teams with domain-specific ranking requirements (for example, a package search where download count should rank higher than attribute match position) can reorder these rules and add custom `sort` criteria. This configurability covers the majority of product search use cases without requiring machine learning or external training data.
Typesense's relevance model is similar to Meilisearch's but with more explicit control over the search algorithm. The `num_typos` parameter per query field lets you configure how aggressively typos are tolerated for each searchable attribute independently — a package name field might allow one typo while a short description field allows two. Typesense's `drop_tokens_threshold` and `typo_tokens_threshold` settings handle edge cases where very short queries would otherwise match too broadly or too narrowly. For high-stakes search implementations where small relevance improvements meaningfully affect user behavior, Typesense's granular parameter surface is the most useful of the three self-hosted options.
Algolia's relevance is the deepest and most commercially mature. Beyond the standard ranking formula, Algolia's Query Rules (formerly "query rules and merchandising") let you define if-then logic: if the query contains "react", boost records tagged `framework` to position 0. If the query is empty, return the most downloaded packages. These rules are managed through Algolia's dashboard or the API and require no re-indexing. Algolia's AI Ranking feature uses click and conversion data to automatically adjust ranking for popular queries, surfacing items users historically click on. This closed-loop optimization is unavailable in self-hosted search engines without building a custom ML pipeline.
*[Compare search tooling and backend libraries on PkgPulse →](https://www.pkgpulse.com)*
*See also: [AVA vs Jest](/compare/ava-vs-jest) and [Payload CMS vs Strapi vs Directus](/guides/payload-vs-strapi-vs-directus-headless-cms-nodejs-2026), [amqplib vs KafkaJS vs Redis Streams](/guides/amqplib-vs-kafkajs-vs-redis-streams-message-queue-2026).*