Elasticsearch vs OpenSearch in 2026: Licensing, Performance, Vector Search, Observability and Cost Compared

Elasticsearch vs OpenSearch in 2026: Licensing, Performance, Vector Search, Observability and Cost Compared

Elasticsearch vs OpenSearch in 2026: Licensing, Performance, Vector Search, Observability and Cost Compared

Five years after the fork, the two engines no longer differ mainly on license. They differ on how they want you to query, store and pay for data. Most elasticsearch vs opensearch articles still frame the choice as “open source fork versus proprietary original”. That framing broke in August 2024, when Elastic added the OSI-approved AGPLv3 as a license option. It broke further in 2026, as both projects shipped very different answers to columnar logs, disk-resident vectors and PromQL. This matters now because both lines sit on Lucene 10 and both shipped a major feature release in the last four months: Elastic 9.5 in August 2026 and OpenSearch 3.10 on 17 November 2026. You will leave with a verified version-by-version picture, an honest reading of the vendor benchmarks, illustrative sizing math, migration paths in both directions and a decision matrix by workload.

What this covers: licensing history and what AGPL really changes, query languages, logs storage, vector search engines, benchmarks and their bias, managed-service pricing models, migration and failure modes.

Context and Background

Elasticsearch was created by Shay Banon and built on Apache Lucene, the Java search library that does the actual inverted-index and vector work. For a decade it shipped under Apache 2.0, and Amazon ran it as a managed service. On 14 January 2021, Elastic announced that from release 7.11 the source of Elasticsearch and Kibana would be dual-licensed under the Server Side Public License (SSPL) and the Elastic License, ending Apache 2.0 for new versions. AWS responded by forking the last Apache-licensed code line, 7.10.2, into OpenSearch and OpenSearch Dashboards in 2021.

Two later events reshaped the comparison. On 29 August 2024, Elastic announced that it was adding the GNU Affero General Public License v3 as a third option, alongside SSPL 1.0 and the Elastic License 2.0 (ELv2). The company stressed that existing users were unaffected and that client libraries stay under Apache 2.0. Three weeks later, on 16 September 2024, the Linux Foundation announced the OpenSearch Software Foundation, with AWS, SAP and Uber as premier members. OpenSearch is no longer an AWS project in governance terms, even though AWS remains its largest contributor and commercial operator.

The state of the art in November 2026 looks like this. Elastic’s What’s New page lists Elastic 9.5 as the current feature release, generally available since 4 August 2026. OpenSearch 3.10 was announced on 17 November 2026, two days before this article. OpenSearch also introduced long-term support: in April 2026 the foundation designated 2.19 and 3.6 as LTS lines, with at least 18 months of support per major version.

The incumbents around them matter too. In observability, both engines compete with Prometheus-compatible stores such as Mimir and VictoriaMetrics, which we compared in our Prometheus long-term storage comparison of Thanos, Mimir and VictoriaMetrics. In vector search, both compete with Postgres extensions and purpose-built vector databases, covered in our pgvector vs dedicated vector database analysis. For the licensing primary sources, read Elastic’s 2024 AGPL announcement and the Linux Foundation’s OpenSearch Software Foundation press release.

The thesis of this article is simple. In 2026 the license question is mostly settled for internal use, and the real divergence is architectural. Elastic is moving toward columnar storage, ES|QL and PromQL as a unified query surface, and auto-tuned disk-resident vectors. OpenSearch is moving toward pluggable native engines, PPL with Calcite, and a foundation-governed release train with LTS. Pick the engine whose direction matches your workload, not the one whose 2021 license story you remember.

Elasticsearch vs OpenSearch: The 2026 Reference Comparison

Elasticsearch vs OpenSearch in 2026 is a choice between two Lucene 10 engines that share a 2021 ancestor but now diverge on licensing (AGPLv3, SSPL or ELv2 versus Apache 2.0), query language (ES|QL versus PPL and SQL), vector design (BBQ and DiskBBQ versus pluggable Faiss, Lucene and native engines), and governance (single vendor versus Linux Foundation).

Elasticsearch vs OpenSearch lineage from the 2021 fork to Elasticsearch 9.5 and OpenSearch 3.10

Figure 1: The licensing and release lineage of Elasticsearch and OpenSearch, 2021 to November 2026.

Figure 1 traces both lines from the shared Apache 2.0 ancestor, Elasticsearch 7.10.2. The left branch shows Elastic’s license moves: SSPL or ELv2 from 7.11 in January 2021, then the AGPLv3 option in August 2024, then Elasticsearch 9.0 on Lucene 10 in April 2025 and 9.5 in August 2026. The right branch shows the fork, the move to the Linux Foundation in September 2024, OpenSearch 3.0 on Lucene 10 in May 2025, the first 3.x LTS release in April 2026 and 3.10 in November 2026.

The table below is the snippet-ready summary. Every row was checked against the vendor’s own release notes or press material this month.

Dimension Elasticsearch (Nov 2026) OpenSearch (Nov 2026)
Latest feature release 9.5, GA 4 Aug 2026 3.10, announced 17 Nov 2026
Long-term support Elastic support policy per version 2.19 and 3.6 designated LTS, 18+ months
Core library Lucene 10 (since 9.0, Apr 2025) Lucene 10 (since 3.0, May 2025)
Source license AGPLv3, SSPL 1.0 or ELv2, user’s choice Apache 2.0
Governance Elastic N.V. OpenSearch Software Foundation, Linux Foundation
Piped query language ES|QL, with PromQL embedded in 9.5 PPL, plus SQL, Calcite-based engine
Vector quantization BBQ default, DiskBBQ, 2/4/7-bit options 1/2/4-bit scalar, fp16, bf16, product quantization via Faiss
Vector engines Lucene only Lucene, Faiss, native sparse, experimental Intel SVS
Hybrid search RRF retriever Hybrid query, fusion mode with RRF and normalization
Managed serverless Elastic Cloud Serverless, VCUs billed in ECUs Amazon OpenSearch Serverless, OCUs
Java runtime Bundled JDK Java 21 minimum since 3.0

Licensing: AGPL changed the label, not the boundary

The most misunderstood row is the license. Since August 2024 you can take Elasticsearch source under AGPLv3, which the Open Source Initiative approves. That means “Elasticsearch is not open source” is no longer accurate. However, AGPL carries a network-interaction clause. If you modify the software and let users interact with it over a network, you must offer them your modified source. For an internal logging cluster that you never modify, this rarely matters. For a SaaS vendor that patches the engine and exposes search to customers, it matters a great deal.

There is a second subtlety. Elastic’s announcement covers the “free portion” of the source code, and Elastic states that binary distributions were unchanged. Features gated by subscription remain under the Elastic License in practice. So the AGPL option widens what you may do with the code, but it does not unlock paid features. OpenSearch’s Apache 2.0 license is permissive: no copyleft, no network clause and no feature tiers. Every plugin in the default distribution, including security, alerting and anomaly detection, ships under the same terms.

Our reading, labelled as opinion: legal teams that blocked Elasticsearch in 2021 because SSPL was not OSI-approved should revisit the decision, because AGPL is on most corporate approved lists with conditions. Teams that embed or resell search should still prefer Apache 2.0, because AGPL’s source-offer duty is real and ELv2 explicitly prohibits offering the product as a managed service.

Shared Lucene 10 base, diverging engines above it

Both engines moved to Lucene 10 within a month of each other. Elastic’s 9.0 announcement on 15 April 2025 describes the release as built on Lucene 10, crediting it with better parallelism and hardware optimisation. OpenSearch’s 3.0 announcement on 6 May 2025 also names Lucene 10, and sets Java 21 as the minimum runtime. That shared base means raw inverted-index performance, segment merging and codec fundamentals converge over time. As a result, the differences that matter sit above Lucene: query planners, aggregation implementations, storage modes, vector engines and the default settings each project ships.

Defaults matter more than most comparisons admit. Elastic’s own 2023 benchmark notes that OpenSearch’s data stream default codec was best_speed while Elasticsearch’s was best_compression. Its 2024 vector benchmark notes that concurrent segment search was on by default in Elasticsearch but off in OpenSearch. Those are configuration choices, not engine limits, and a fair evaluation normalises them.

Governance and release cadence

Elastic ships a minor release roughly every quarter: 9.2 on 23 October 2025, 9.4 on 5 May 2026 and 9.5 on 4 August 2026. OpenSearch shipped 3.3 on 14 October 2025, 3.9 on 29 September 2026 and 3.10 on 17 November 2026, a faster cadence of roughly six to eight weeks. The OpenSearch LTS programme answers a common enterprise objection. Before April 2026, teams on OpenSearch had to keep upgrading to stay supported. Now the foundation commits to a minimum of 18 months per LTS major version and a 60-day fix target for medium and high severity vulnerabilities after disclosure.

Elastic’s model is different. A single company controls the roadmap, which brings coherent product design across Elasticsearch, Kibana, Elastic Agent and Elastic Security. The trade-off is that the roadmap follows Elastic’s commercial priorities, such as Agent Builder, Workflows and Elastic Cloud Serverless. OpenSearch’s roadmap reflects the priorities of AWS, other premier members and contributors such as Atlassian and Intel, which shows in features like routed deletes and the Intel SVS vector engine.

Deeper Analysis: Query Languages, Logs, Vectors, Benchmarks and Cost

The elasticsearch vs opensearch reference table tells you what exists. This section explains how the differences behave under load, where the published numbers come from, and how to reason about cost before you run your own tests.

Query surfaces: ES|QL with PromQL versus PPL with Calcite

Both projects concluded that JSON Query DSL is a poor interface for analysts and for AI agents, and both built a piped language. Elastic’s ES|QL (Elasticsearch Query Language) has grown fast. Version 9.1 made LOOKUP JOIN and ES|QL over cross-cluster search generally available. Version 9.2 added smart lookup joins that match on multiple fields and on expressions such as <, > and !=, plus native time-series commands such as RATE, TBUCKET and TS, which Elastic says run up to 10x faster. Version 9.4 made ES|QL time-series support GA and previewed subqueries, approximate queries and logical views. Version 9.5 embeds native PromQL inside ES|QL, so existing Grafana dashboards can point at Elastic.

OpenSearch’s answer is PPL (Piped Processing Language) on an Apache Calcite-based engine, plus SQL. Release 3.4 added chart, streamstats, multisearch, replace and appendpipe. Release 3.9 added query profiling with an operator tree of estimated and actual row counts, a lint API for CI pipelines, and SQL RANK(), DENSE_RANK() and UNION. Release 3.10 added time-range index pruning, streaming and asynchronous queries with progress tracking, cross-cluster PPL, and a dynamic regex step limit (plugins.ppl.regex.match.limit, default 100,000) that protects nodes from runaway parse and rex patterns.

The practical difference is ergonomics and portability. ES|QL is one language for search, logs, metrics and security, and PromQL inside it lowers the switching cost from Prometheus. PPL feels familiar to Splunk users and now has mature guardrails for multi-tenant clusters. Neither language is portable to the other engine. If you build dashboards and detection rules in one, migration later means rewriting them, which we treat as a hidden cost in the decision matrix.

Observability storage: columnar mode versus derived source and pruning

Logs dominate most clusters by volume, so storage efficiency drives total cost. Elastic 9.5 introduced Columnar Mode as a technical preview. It stores each field once in a column store with no inverted index by default. The Columnar Logs profile keeps one inverted index on the message field so full-text search stays fast, and stores everything else in columns. Elastic’s 9.5 post promises “meaningfully smaller storage footprints” but publishes no percentage, so treat any savings figure you read elsewhere as unverified until you test it.

Elastic’s metrics story is more quantified. The 9.5 announcement claims a new ES95 codec gives about 20% further storage reduction to roughly 3 bytes per sample, and up to 2.5x better storage efficiency and up to 30x faster queries than Prometheus. Those are vendor claims against a different product, useful as direction rather than as planning inputs. If you are weighing those claims against a dedicated metrics backend, compare transport costs too; our OTLP vs Prometheus remote write analysis covers the wire-level side.

OpenSearch attacks the same problem differently. Version 3.0 introduced derived source for vectors, which rebuilds _source from stored field data and cuts storage by about one third for vector-heavy indexes, according to the 3.0 announcement. Version 3.9 added opt-in index-level search pruning; in local tests with 90 daily indexes, the project reports tail latency down more than 80% and can_match transport requests down nearly 98%. Version 3.10 extended pruning to PPL. OpenSearch also ships a separately versioned Observability Stack with APM service maps, agent traces grouped by gen_ai.conversation.id, and no-code Prometheus alert rules.

For ingest, both engines accept OpenTelemetry data, but the collection tier is where most teams get the architecture right or wrong. See our OpenTelemetry Collector architecture guide for receiver, processor and exporter pipelines that can feed either backend.

OpenSearch vector search versus Elasticsearch BBQ

OpenSearch vector search engines compared with Elasticsearch BBQ and DiskBBQ paths

Figure 2: Vector query paths in Elasticsearch, one Lucene-based path with BBQ variants, and OpenSearch, several pluggable engines feeding the same hybrid fusion stage.

Figure 2 shows the structural difference. A query vector in Elasticsearch hits a dense_vector field that is always served by Lucene. What varies is the quantization and layout: HNSW with Better Binary Quantization, DiskBBQ clusters read from disk, or the new VectorDB index mode that picks settings for you. In OpenSearch the same query hits a knn_vector field whose engine you choose per field: Lucene HNSW, Faiss HNSW or IVF, the native sparse engine for neural sparse vectors, or the experimental sandbox engine. Both converge on rescoring and reciprocal rank fusion for hybrid search.

Elastic’s path has been about compression and automation. BBQ arrived as a technical preview in 8.16, went GA in 9.0, and became the default in 9.1. DiskBBQ arrived in 9.2 as a clustering-based layout that searches compact clusters directly from disk; Elastic’s 9.2 post cites sub-20 ms latency with 100 MB of total memory, without publishing the dataset size in that post. Version 9.4 improved DiskBBQ latency at least 3x for restrictive filters, added 2, 4 and 7-bit quantization, and made GPU indexing via NVIDIA cuVS GA, with up to 12x higher indexing throughput and 7x faster force merges for self-managed users. Version 9.5 added VectorDB index mode and auto-calibration, which sets quantization depth, preconditioning and oversampling from a statistical analysis of the indexed vectors.

OpenSearch’s path has been about choice and native code. Release 3.9 moved neural sparse ANN search to a C++ engine based on the SEISMIC algorithm, reporting 39% higher throughput, 3.3x faster index builds and an 8x smaller JVM heap on an 8.8-million-document corpus. It also added half_float vectors, a bf16 encoder that uses AVX-512 BF16 instructions on recent Intel CPUs, and 2-bit and 4-bit scalar quantization alongside the existing 1-bit option. Release 3.10 debuted a sandbox engine framework with Intel Scalable Vector Search, using Vamana graphs and LeanVec compression, reporting about 2.6x the query throughput of Faiss HNSW-fp16 at 0.95 recall with 37 to 40% less graph memory.

The trade-off is clear. Elasticsearch gives you one engine that tunes itself, which reduces operational decisions. OpenSearch gives you several engines with different memory and recall curves, which rewards teams that benchmark carefully. If you want to understand why quantization depth and graph type move these curves, read our HNSW vs DiskANN vs IVF-PQ index internals guide; filtered queries have their own pitfalls, covered in our filtered vector search deep dive.

Hybrid search is now close to parity. Elasticsearch offers an RRF retriever. OpenSearch 3.10 added fusion mode, which defines normalization and combination inside the hybrid query body, so no search pipeline is required. Fusion mode supports RRF plus min-max, z-score and L2 normalization, nests inside bool and dis_max, and accepts a per-request weights parameter. That removes a long-standing ergonomic gap where OpenSearch hybrid queries required a separately configured pipeline.

OpenSearch vs Elasticsearch performance: reading the benchmarks honestly

Every widely cited elasticsearch vs opensearch benchmark was paid for or run by one of the two camps. That does not make them useless, but it does make the configuration details more important than the headline. The table summarises the three most cited studies with their sponsor, versions and claims.

Study Sponsor and date Versions Headline claim Key caveat
Elastic “performance gap” Elastic, 8 Aug 2023 ES 8.7 vs OpenSearch 2.7 ES 40% to 140% faster, 37% less disk by default Synthetic 1 TB log data; different default codecs
Elastic vector comparison Elastic, 26 Jun 2024 ES 8.14 vs OpenSearch 2.14 ES 2x to 12x faster on vector search int8 vs fp16 quantization; concurrent segment search defaults differ
Trail of Bits benchmark Commissioned by AWS, 6 Mar 2025 OpenSearch 2.17.1 vs ES 8.15.4 OpenSearch 1.6x faster on Big5; 11% faster on vectorsearch Only Apache 2.0 and ELv2 features; ES slower only on some categories

Look inside the Trail of Bits numbers and the picture is mixed rather than one-sided. On the Big5 workload, OpenSearch was 2.42x slower on text queries but 3.38x faster on term aggregations and 16.55x faster on date histograms. On vectorsearch, OpenSearch’s Faiss engine was 13.8% faster than Elasticsearch, while OpenSearch’s own Lucene engine was 258.2% slower than Elasticsearch’s Lucene. In other words, each engine wins categories, and the aggregate depends on the workload mix that the study chose.

Elastic’s own studies show the same pattern in reverse. Its 2024 vector post shows OpenSearch’s Faiss and NMSLIB engines matching or beating Elasticsearch on recall in some tasks, even while the latency headline favours Elasticsearch. Elastic’s 9.0 announcement also claims BBQ is 5x faster than OpenSearch, without test conditions in that post. All of these studies predate Lucene 10 on at least one side, and both engines have shipped many releases since.

Our methodology caveat, stated plainly: there is no independent, current, cross-version benchmark of Elasticsearch 9.5 versus OpenSearch 3.10 that we could verify. Any article quoting a single “X is N times faster” number for 2026 is extrapolating. The right move is to run OpenSearch Benchmark or Rally with your own documents and query mix, with codecs, replicas, refresh intervals and concurrent segment search normalised across both clusters.

Managed services and cost models

For elasticsearch vs opensearch cost comparisons, the managed offerings price differently, which makes direct comparison awkward. Elastic Cloud Serverless bills in Elastic Consumption Units, with a nominal value of US$1.00 per ECU. Compute is metered as Virtual Compute Units of three kinds, search, ingest and machine learning, billed hourly, plus storage. Elastic’s December 2025 explainer gives illustrative rates: a search VCU at 0.09 ECU, so ten VCU-hours cost US$0.90, and storage at about 0.047 ECU per GB-month, so 100 GB for a month costs US$4.70. Elastic stresses that real rates vary by region and provider. Search VCUs can scale to zero after fifteen minutes of inactivity, though a minimum stays allocated once the interactive dataset passes a size threshold. Elastic Cloud Serverless runs in 29 regions per the 9.4 announcement.

Amazon OpenSearch Serverless bills in OpenSearch Compute Units. AWS documentation defines an OCU as 6 GiB of memory with corresponding vCPU and data transfer to Amazon S3, provisioned separately for indexing and search. The Classic architecture keeps a minimum of 2 OCUs always on. AWS’s NextGen architecture, described in a 28 May 2026 post, decouples compute from a shared storage layer, scales to zero after a 10-minute idle timeout, returns from zero in about 10 seconds with queued requests, and is reported at up to 60% lower cost than provisioning domains for peak load. Vector collections on NextGen use GPUs automatically to build HNSW indexes. At launch, NextGen supports search and vector search collections but not time-series collections. We did not verify a current OCU-hour list price this run; check the AWS pricing page for your region.

Provisioned options still dominate large estates. Amazon OpenSearch Service managed domains supported OpenSearch 3.3 from November 2025, and many other vendors, including Aiven, Instaclustr and Oracle Cloud, run OpenSearch. Elasticsearch can be self-managed under AGPL or ELv2, run on Elastic Cloud Hosted, or run under Elastic Cloud on Kubernetes.

Illustrative sizing math

The following worked example is illustrative, not a benchmark. It shows how to reason about shard count and heap for a logs cluster before you test. Assume 500 GB of raw logs per day, 30 days of hot retention and one replica.

Step Illustrative assumption Result
Indexed size per day 1.0x raw after compression, varies 0.5x to 1.5x about 500 GB
Hot data with one replica 500 GB x 30 days x 2 copies about 30 TB
Shard target 30 to 50 GB per primary shard, common guidance about 10 to 17 primaries per day
Total shards in hot tier 15 primaries x 2 copies x 30 days about 900 shards
Data nodes at 4 TB usable disk with 75% watermark headroom 30 TB divided by 3 TB per node about 10 nodes
Heap per node at most half of RAM, below about 31 GB for compressed pointers 30 GB heap on 64 GB hosts

Two consequences follow, and they apply to both engines. First, rollover by size rather than by day is the strongest lever against shard explosion. Second, the storage mode you pick changes the second row by a large factor: columnar logs in Elasticsearch, best_compression in either engine, and derived source for vectors in OpenSearch all shrink it. Re-run this table with your own measured compression ratio after a one-day ingest test.

Decision matrix by use case

Elasticsearch vs OpenSearch decision flowchart by license and workload

Figure 3: A decision flow for choosing between Elasticsearch and OpenSearch based on license constraints and primary workload.

Figure 3 starts from the constraint that usually decides the elasticsearch vs opensearch outcome, license, and then branches by workload. If Apache 2.0 is mandatory, OpenSearch wins outright. Otherwise, logs and metrics depend on the query language your team wants, SIEM depends on the security product you prefer, vector workloads depend on cloud alignment, and application search is close enough that your own benchmark should decide. The matrix below scores each workload on a three-point scale. Scores are our editorial judgement from the verified features above, not measured results.

Workload Elasticsearch OpenSearch Deciding factor
Log analytics at scale Strong: Columnar Logs preview, ES|QL Strong: PPL, pruning, Observability Stack Query language preference and storage tests
Metrics with PromQL Strong: native PromQL in ES|QL Medium: PromQL via Prometheus data sources Whether metrics live in the engine or beside it
SIEM and threat detection Strong: Elastic Security, AI alert triage in 9.5 Medium: Security Analytics plugin Detection content and analyst workflow
Vector search and RAG Strong: BBQ, DiskBBQ, auto-calibration Strong: Faiss, native sparse, GPU builds on AWS Engine choice versus self-tuning
E-commerce and app search Strong Strong Your own relevance and latency tests
Embedding in a SaaS product Weak: AGPL source offer, ELv2 service limits Strong: Apache 2.0 License, decisively
AWS-native serverless Medium: Elastic Cloud Serverless runs on AWS Strong: OpenSearch Serverless NextGen Procurement and IAM integration

Migration paths in both directions

Elasticsearch to OpenSearch migration paths using snapshots, reindex from remote and traffic replay

Figure 4: Migration paths between Elasticsearch and OpenSearch, from snapshot-based reindexing to live traffic replay and alias cutover.

Figure 4 shows three ways to move data from Elasticsearch to OpenSearch, and the reverse path. The oldest and simplest is a snapshot restore, but it only works when the source index was created by a compatible version. OpenSearch forked from 7.10.2, so indexes created by Elasticsearch 7.10 or earlier can generally be restored, while indexes written by later Elasticsearch versions cannot be restored directly. The general Lucene rule also applies within each line: an index created two majors ago must be reindexed before an upgrade, not just restored.

The second path is Reindex-from-Snapshot (RFS), part of the OpenSearch Migration Assistant. RFS reads documents out of a snapshot in object storage instead of querying the live source, so it does not load the production cluster. AWS’s November 2024 post describes migrating across major versions, for example Elasticsearch 6.8 to OpenSearch 2.x. In AWS’s own test, a 5 TiB source of about 3.9 billion documents moved from Elasticsearch 7.10 to OpenSearch 2.15 in about 35 minutes using 200 workers, at roughly 2,497 MiB per second, with about US$10 of worker compute. AWS notes that RFS throughput is limited by how fast the target cluster absorbs writes, so treat these numbers as an upper bound from a heavily provisioned target of fifteen r7gd.16xlarge data nodes. We could not verify the current full source-version matrix for Migration Assistant this run, so confirm your exact source version in the OpenSearch documentation before planning.

The third path is reindex-from-remote, where the target cluster pulls documents over HTTP from the source with a _reindex request that names a remote host. It works in both directions and needs no shared storage, but it is slower, loads the source cluster, and requires the remote host to be allow-listed on the target. Migration Assistant also includes capture-and-replay, which records live traffic against the source and replays it against the target so you can compare results before cutover.

Moving from OpenSearch to Elasticsearch has no vendor tooling equivalent to RFS. In practice, teams use reindex-from-remote into Elasticsearch 9.x, Logstash with an OpenSearch input and Elasticsearch output, or a dual-write from the ingestion tier. The collection tier is the cleanest place to fork traffic; our OpenTelemetry Collector vs Vector vs Fluent Bit comparison shows how each agent fans out to two backends.

In an elasticsearch vs opensearch migration, data is the easy part. Mappings mostly carry across, but vector field types differ (dense_vector versus knn_vector), as do security configurations, ingest pipelines that use engine-specific processors, Kibana versus OpenSearch Dashboards saved objects, ES|QL versus PPL queries, and alerting or detection rules. Budget the migration by counting dashboards and rules, not terabytes.

Trade-offs, Gotchas, and What Goes Wrong

In any elasticsearch vs opensearch evaluation, client and API drift is the first trap. The engines shared one REST API in 2021, and much of it still looks the same. However, five years of independent development mean that clients, plugins and tooling built for one increasingly fail on the other. Elastic’s client libraries remain Apache 2.0, but newer Elasticsearch clients check that they talk to a genuine Elasticsearch server, and OpenSearch publishes its own clients. Pin the client to the engine and test upgrades on both sides of any compatibility layer.

Shard explosion is the most common failure in both engines. Every shard carries heap overhead for segment metadata, mappings and cluster state. Daily indices with many primaries across hundreds of tenants can push a cluster into tens of thousands of shards, slowing cluster-state updates and master elections. The fixes are identical: size-based rollover, fewer primaries, index lifecycle policies (ILM in Elasticsearch, ISM in OpenSearch), and shrink or merge for older data.

Mapping explosion is the second classic. Dynamic mapping on unstructured JSON can create thousands of fields per index, each adding to cluster state and memory. Both engines cap total fields per index by default, but teams often raise the limit instead of fixing the source. Use explicit mappings or flattened types such as flattened in Elasticsearch or flat_object in OpenSearch, which OpenSearch 3.10 made filterable and castable in PPL.

Split-brain is mostly history, but not entirely. Elasticsearch 7.0 replaced the minimum_master_nodes setting with automatic voting configuration, and OpenSearch inherited that cluster coordination layer from the fork. A misconfigured cluster with two master-eligible nodes, or a careless manual bootstrap, can still produce outages. Always run three dedicated master-eligible nodes, called cluster manager nodes in OpenSearch, for production clusters.

Heap pressure remains the operational tax of a JVM engine. Keep heap at or below half the host RAM and under the compressed-pointer threshold, leave the rest to the filesystem cache, and watch circuit-breaker trips. Vector workloads complicate this. Elasticsearch’s DiskBBQ and OpenSearch’s native sparse engine both move vector work off-heap or onto disk, which helps, but HNSW graphs that do not fit in page cache still collapse latency. Size page cache to the quantized vector footprint, not the raw one.

Benchmark-driven decisions are the last gotcha. As shown earlier, each vendor’s benchmark favours its own defaults. A decision based on any single published number, including those cited here, is a decision based on someone else’s workload.

Practical Recommendations

Start the elasticsearch vs opensearch decision from constraints, not features. If your organisation must ship search inside a product sold to customers, or simply wants the least legal review, OpenSearch’s Apache 2.0 license is the safer default. If AGPL or ELv2 is acceptable, the decision becomes technical, and Elasticsearch’s integrated stack of ES|QL, PromQL, Elastic Security and auto-tuned vectors is the stronger single-vendor platform in 2026. OpenSearch is the stronger choice when you are committed to AWS, want an LTS line governed by a foundation, or want to choose vector engines per field.

Treat both projects as moving targets. Elastic ships roughly quarterly and OpenSearch roughly every six to eight weeks. Lock to an LTS or a supported minor, and schedule a re-evaluation each year rather than trusting a comparison written before your last upgrade. Among the wider set of Elasticsearch alternatives, consider ClickHouse for pure log analytics and a dedicated vector database for very large embedding sets, but only after you have measured the engine you already run.

Checklist before you commit:

  • Confirm the license with legal: AGPLv3, SSPL or ELv2 for Elasticsearch; Apache 2.0 for OpenSearch.
  • Run Rally or OpenSearch Benchmark on one day of your own data, with codecs, replicas and concurrent segment search normalised.
  • Measure compression on your logs and re-run the sizing table with the real ratio.
  • Count dashboards, detection rules and saved queries; that number drives migration cost.
  • Pick a support line: an Elastic subscription, OpenSearch 3.6 LTS, or a managed service SLA.
  • Set size-based rollover and explicit mappings on day one.

Frequently Asked Questions

Is OpenSearch better than Elasticsearch?

Neither is better in general. OpenSearch is better when you need an Apache 2.0 license, foundation governance, a designated LTS line such as 3.6, or deep AWS integration through OpenSearch Serverless. Elasticsearch is better when you want one vendor’s integrated stack: ES|QL with native PromQL, Elastic Security, and self-tuning vector search with BBQ and DiskBBQ. Published benchmarks conflict, because each camp sponsored its own study. The only reliable answer for your team comes from running both engines on your own documents and queries with normalised settings.

Is Elasticsearch open source again?

Yes, with conditions. On 29 August 2024, Elastic added the OSI-approved GNU AGPLv3 as a license option for the source code of Elasticsearch and Kibana, alongside SSPL 1.0 and Elastic License 2.0. You choose which license applies. AGPL requires you to offer your modified source to users who interact with the software over a network. Elastic’s announcement also states that binary distributions were unchanged and client libraries remain Apache 2.0, so subscription features stay governed by Elastic’s commercial terms.

Can OpenSearch read Elasticsearch indexes or snapshots?

Partly. OpenSearch forked from Elasticsearch 7.10.2, so snapshots of indexes created by Elasticsearch 7.10 or earlier can generally be restored into OpenSearch, subject to Lucene’s version rules. Indexes created by later Elasticsearch versions cannot be restored directly. For those, use the OpenSearch Migration Assistant’s Reindex-from-Snapshot, which reads documents from a snapshot and re-indexes them, or reindex-from-remote over HTTP. Verify your exact source version against the current Migration Assistant documentation before you plan the cutover.

Which is faster, OpenSearch or Elasticsearch?

It depends on the query type and settings. An AWS-commissioned Trail of Bits study in March 2025 found OpenSearch 2.17.1 about 1.6x faster overall on the Big5 workload, yet 2.42x slower on text queries. Elastic’s own studies found Elasticsearch 40% to 140% faster on logs in 2023 and 2x to 12x faster on vectors in 2024. All used versions that are now outdated, and each used different defaults. No verified independent benchmark of Elasticsearch 9.5 against OpenSearch 3.10 existed when this was written.

Does OpenSearch support vector search and RAG?

Yes. OpenSearch vector search uses the knn_vector field with a choice of engines: Lucene, Faiss and, since 3.9, a native C++ engine for neural sparse vectors. Release 3.9 added half_float vectors, a bf16 encoder and 2-bit and 4-bit scalar quantization. Release 3.10 added an experimental Intel SVS engine and a hybrid fusion mode with reciprocal rank fusion. On AWS, OpenSearch Serverless offers vector search collections, and the NextGen architecture uses GPUs automatically to build HNSW indexes.

What are the main Elasticsearch alternatives besides OpenSearch?

The right alternative depends on the workload. For log analytics, columnar databases such as ClickHouse often cost less per terabyte. For metrics, Prometheus-compatible stores like Mimir or VictoriaMetrics are purpose-built. For vector search, Postgres with pgvector or dedicated vector databases such as Qdrant or Milvus compete directly. For application search, lighter engines exist. OpenSearch remains the only drop-in fork with a closely related API and the same Lucene foundation, which is why it is usually evaluated first.

Further Reading

References

  1. Elastic, “Licensing change,” 14 January 2021. https://www.elastic.co/blog/licensing-change
  2. Elastic via Business Wire, “Elastic Announces Open Source License for Elasticsearch and Kibana Source Code,” 29 August 2024. https://www.businesswire.com/news/home/20240829537786/en/Elastic-Announces-Open-Source-License-Elasticsearch-Kibana
  3. Linux Foundation, “Linux Foundation Announces OpenSearch Software Foundation,” 16 September 2024. https://linuxfoundation.org/press/linux-foundation-announces-opensearch-software-foundation-to-foster-open-collaboration-in-search-and-analytics
  4. Linux Foundation, “OpenSearch Software Foundation Strengthens Enterprise Readiness With New Long-Term Support Versions,” 16 April 2026. https://www.linuxfoundation.org/press/opensearch-software-foundation-strengthens-enterprise-readiness-with-new-long-term-support-versions
  5. Elastic, “Elastic 9.0/8.18,” 15 April 2025. https://www.elastic.co/blog/whats-new-elastic-9-0-0
  6. Elastic, “Elastic 9.2,” 23 October 2025. https://www.elastic.co/blog/whats-new-elastic-9-2-0
  7. Elastic, “Elastic 9.4,” 5 May 2026. https://www.elastic.co/blog/whats-new-elastic-9-4-0
  8. Elastic, “Elastic 9.5,” 4 August 2026. https://www.elastic.co/blog/whats-new-elastic-9-5-0
  9. OpenSearch Project, “OpenSearch 3.0 enhances vector database performance,” 6 May 2025. https://opensearch.org/announcements/opensearch-3-0-enhances-vector-database-performance/
  10. OpenSearch Project, “Introducing OpenSearch 3.4,” 16 December 2025. https://opensearch.org/blog/introducing-opensearch-3-4/
  11. OpenSearch Project, “Get to know OpenSearch 3.9,” 29 September 2026. https://opensearch.org/blog/get-to-know-opensearch-3-9/
  12. OpenSearch Project, “Explore OpenSearch 3.10,” 17 November 2026. https://opensearch.org/blog/explore-opensearch-3-10/
  13. Trail of Bits, “Benchmarking OpenSearch and Elasticsearch,” 6 March 2025. https://blog.trailofbits.com/2025/03/06/benchmarking-opensearch-and-elasticsearch/
  14. Elastic, “Elasticsearch vs. OpenSearch: Unraveling the performance gap,” 8 August 2023. https://www.elastic.co/blog/elasticsearch-opensearch-performance-gap
  15. Elastic Search Labs, “Elasticsearch vs. OpenSearch: Vector Search Performance Comparison,” 26 June 2024. https://www.elastic.co/search-labs/blog/elasticsearch-opensearch-vector-search-performance-comparison
  16. Elastic Search Labs, “Elasticsearch Serverless pricing demystified: VCUs and ECUs explained,” 19 December 2025. https://www.elastic.co/search-labs/blog/elasticsearch-serverless-pricing-vcus-ecus
  17. AWS documentation, “What is Amazon OpenSearch Serverless?” https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-overview.html
  18. AWS Big Data Blog, “Amazon OpenSearch Serverless: cost-effective search capabilities at any scale,” 28 May 2026. https://aws.amazon.com/blogs/big-data/amazon-opensearch-serverless-cost-effective-search-capabilities-at-any-scale
  19. AWS Big Data Blog, “Accelerate your migration to Amazon OpenSearch Service with Reindexing-from-Snapshot,” 22 November 2024. https://aws.amazon.com/blogs/big-data/accelerate-your-migration-to-amazon-opensearch-service-with-reindexing-from-snapshot

By Riju — about

Comments

No comments yet. Why don’t you start the discussion?

Leave a Reply

Your email address will not be published. Required fields are marked *