Weaviate

Editor’s note: We combine independent analysis, data collection, and hands-on testing to review data and AI tools, weighing pricing transparency, real-world adoption signals, development momentum, openness and exit costs, practitioner sentiment, and our editorial verdict.

Quick verdict: We recommend Weaviate for teams that need hybrid (BM25 plus vector) search, multimodal retrieval, or many-tenant SaaS isolation, with a real exit path through BSD-3 self-hosting. The eyes-open trade-off: schema-first modeling and a v4 client rewrite with zero backward compatibility.

In this Weaviate review, I’ll take a closer look at pricing, features, and operational costs, and where it beats the other vector databases in our directory.

Key Takeaways 🔍

• Native hybrid search fuses BM25, vectors, and filters in one query; relativeScoreFusion is the default since v1.24
• The free tier is always free: 100,000 objects, 1 GB memory, 10 GB disk, 3 tenants; Flex from $45/month (as of September 2026)
• gRPC cut query round-trips 40-70% versus the REST plus GraphQL path, per Weaviate’s own benchmarks
• Cloud pricing keeps moving: three different tier structures published within roughly a year
• Self-hosting gets heavy: 130 GB of memory reported at 60 million objects; the v4 client rewrite dropped all v3 compatibility

Pros and Cons

The pros are architectural; the cons are operational.

How Much Does Weaviate Cost?

Weaviate Cloud has carried three different tier structures in roughly a year. Price sheets published in 2026 list an older Standard ($25), Professional ($135), and Business Critical ($450) lineup, and a later Flex ($45), Plus ($280), and Premium ($400) lineup. The live pricing page, checked September 2026, shows neither. The free tier changed shape too, from a 14-day sandbox that expired automatically to a capacity-capped plan with no end date. Current tiers:

• Free ($0): always free, no credit card; 100,000 objects, 1 GB memory, 10 GB disk, 1 collection, up to 3 tenants, 2,000 embedding requests per day, 1,000 Query Agent requests per month, best-effort SLA, email-only support
• Flex (from $45/month): pay as you go, no contract; up to 1,000 collections, 99.5% uptime SLA, usage billed at $0.00465 per 1 million vector dimensions, $0.12/GiB storage, and $0.029/GiB backup
• Premium (custom quote): shared or dedicated infrastructure, up to 99.95% uptime SLA, roughly 40 regions across AWS, GCP, and Azure, from $0.003875 per 1 million dimensions, $0.10/GiB storage, and $0.02/GiB backup

Tier	Price	Capacity	Uptime SLA	Usage rates
Free	$0, always free	100,000 objects, 1 GB memory, 10 GB disk, 1 collection, 3 tenants	Best effort	2,000 embedding requests/day included
Flex	From $45/month	Up to 1,000 collections	99.5%	$0.00465 per 1M dimensions, $0.12/GiB storage, $0.029/GiB backup
Premium	Custom quote	Shared or dedicated, ~40 regions	Up to 99.95%	$0.003875 per 1M dimensions, $0.10/GiB storage, $0.02/GiB backup

Self-hosting carries no license fee: the database is BSD-3-Clause, so you can run it commercially without paying Weaviate anything. The real bill is hardware and operations. One community forum thread reports 130 GB of memory at 60 million objects even with the vector cache capped, the line item no price sheet prints.

Is Weaviate Good Value for Money?

• The free tier is more generous than Qdrant’s (100,000 objects, 1 GB memory, and 10 GB disk versus 0.5 vCPU, 1 GB RAM, and about 4 GB disk), and both skip the credit card
• Dimension-based metering is a real cost lever: at $0.00465 per 1 million dimensions, switching from a 3,072-dimension embedding model to a 768-dimension one cuts the vector portion of your bill by three quarters
• Pinecone has no self-host escape valve at any price, and one practitioner cost comparison puts it at roughly 3-8x the cost of Postgres with pgvector at equivalent vector counts
• The repeated restructuring is itself a cost risk: a budget built on today’s quote may not map to the tiers at renewal

Author’s Testing Notes 📝

Prototype on the Free tier: 100,000 objects is enough to test hybrid search on a real corpus, and it never expires. For production, Flex’s $45 floor with a 99.5% SLA is the sane default. Self-host only with genuine DevOps capacity; the forum memory reports above are what that path looks like at scale.

One more thing: treat any third-party Weaviate pricing article, including this review’s figures, as stale until checked against the live pricing page. Weaviate has changed the structure more than once in a year.

— Panoply reviewer

My Experience With Weaviate

Weaviate will not accept a single object until you have declared what your data looks like. That one design decision shapes the entire workflow, so I’ll walk through it in the order you’ll meet it: modeling, querying, deploying.

🧱 Defining a Collection (Schema First)

With the v4 Python client, I connected through a helper rather than a constructor: weaviate.connect_to_local() for a local instance, with keyword-only arguments for host, port, and credentials. Before ingesting anything, I had to define a collection and its properties: names, data types, and which vectorizer module handles embedding. That module choice is per collection: text2vec-openai or text2vec-cohere to call a hosted model, text2vec-transformers to run one locally, or multi2vec-clip when images share the collection.

That ceremony buys you typed, validated data, but it bites later. When your metadata needs evolve, adding structure means a formal schema migration, not just writing a new field the way you would drop an extra key into a Qdrant payload. Plan your properties like you would plan a SQL table, because that is effectively what you are doing.

[Screenshot needed: Weaviate Cloud console collection creation] I defined the collection’s properties and vectorizer before loading a single object; Weaviate enforces this order. Source: Panoply

🔍 Running Hybrid Queries

One hybrid call combines BM25 keyword scoring, vector similarity, and metadata filters, where most rivals make you run separate queries and merge results yourself. An alpha parameter sets the balance between the two, from pure keyword at one end to pure vector at the other.

Since v1.24, relativeScoreFusion is the default fusion algorithm. It min-max normalizes both result lists (top score to 1, bottom to 0) before combining them, so a strong BM25 match can actually outrank a mediocre semantic one.

🐳 Self-Hosting with Docker

For local development, a single docker-compose.yml gets a node running. Production is a Kubernetes job: a cluster at v1.23 or later, Helm v3, and PersistentVolumeClaims with ReadWriteOnce mounts, with settings managed in the Helm chart’s values.yaml. Below a few million vectors with low write volume, Weaviate’s own guidance says a single-node Docker deployment, or just the managed Free tier, removes most of the operational surface.

Author’s Testing Notes 📝

If you are picking up Weaviate today, learn the v4 client idioms directly and skip v3 tutorials entirely. Filters use chained syntax now (Filter.by_property(...), Filter.by_ref(...)), query results expose fields through result.properties[key] rather than direct indexing, and the client requires a server at 1.23.5 or newer. Because v4 removed every piece of v3 compatibility, code copied from a v3-era tutorial fails on exactly these points, so check which client version a sample targets before you paste it.

— Panoply reviewer

The friction concentrates up front: schema design and client idioms. Once a collection exists, the query surface is more expressive than any open-source rival’s.

Hybrid Search: The Feature That Justifies Weaviate

Purely semantic search misses exact strings like error codes and SKUs; purely keyword search misses paraphrases. Weaviate’s answer is architectural: a BM25 inverted index and an HNSW vector index live side by side in the same engine, and one query fuses both score lists.

Two fusion algorithms are available. relativeScoreFusion, the default since v1.24, normalizes each list’s scores to a 0-to-1 range and combines the weighted values. rankedFusion, the older default, keeps only rank positions and discards how far apart the scores were. The newer default matters: it stops a barely-first keyword result from carrying the same weight as a dominant one.

How the main rivals handle hybrid:

• Qdrant does hybrid through sparse encoders you configure and combine yourself
• Pinecone runs a proprietary dense-plus-sparse index whose fusion behavior is less transparent and less tunable
• Elasticsearch is a keyword-first engine with kNN vector search added on, the mirror image of Weaviate’s vector-first design

Among the open-source options I have compared, Weaviate’s is the most complete hybrid implementation: fusion, filters, and the alpha balance all live in one query with inspectable behavior. The alpha parameter from the walkthrough above lets you tune a product-catalog collection toward keyword precision and a support-docs collection toward semantic recall without changing engines or writing merge code.

For RAG over jargon-heavy corpora (product names, error codes, legal citations), hybrid is the difference between finding the answer and finding something similar to the answer. A query for “error E4021 timeout” needs the exact code from BM25 and the paraphrase tolerance of vectors at the same time. The same logic makes hybrid a strong default for conversational search and chatbots, where users mix exact names with loose phrasing. If that describes your data, this feature alone shortlists Weaviate.

Multi-Tenancy and Multimodal: Where Weaviate Wins Outright

A single Weaviate node can run more than 50,000 active shards. That number is the foundation of the platform’s strongest niche: multi-tenant SaaS, where every customer gets real isolation instead of a filter clause.

• Each tenant gets a dedicated shard and its own vector index, so one tenant’s data never mixes with another’s at the index level
• Tenant deletes are fast and contained: dropping a customer drops a shard, not a scan-and-delete across shared storage
• Roughly 20 nodes can serve 1 million concurrently active tenants, per Weaviate’s documentation, with tenant offloading parking inactive tenants cheaply
• Fine print: the cloud Free tier caps you at 3 tenants per collection; self-hosted deployments are bound only by the OS open-file-descriptor limit and your hardware

Pinecone’s namespace model cannot query across tenants in a single API call. Qdrant’s multi-tenancy is manual: collections plus payload-based sharding you design and police yourself. If you run a product with thousands of small customers who each expect their data deleted on request, Weaviate’s model saves you building that layer.

The second outright win is multimodal retrieval. The multi2vec-clip and multi2vec-bind modules (the latter built on Meta’s ImageBind) embed text, images, audio, and video into one shared vector space, searchable together in one query. One production engineering team’s published comparison recommends Weaviate “exclusively for text-image retrieval at production scale” and steers text-only projects elsewhere. That is a narrow criterion, and it is exactly the right one.

One caveat on the vectorizer modules: for third-party models like OpenAI and Cohere, they call the same external embedding APIs you would call yourself, so the convenience adds latency and API cost without removing the provider dependency. Enabling several modules at once also disables the legacy Explore function, a small but documented loss.

APIs and Developer Experience: GraphQL, gRPC, and the v4 Client

The developer adopting Weaviate today inherits two histories at once: a genuinely fast new API path, and the scars of how it got there.

Weaviate exposes three API surfaces: REST, GraphQL, and gRPC. The gRPC interface, stable since v1.23.7 on port 50051, is now the default transport in the Python, TypeScript, Java, and C# clients; the Go client uses gRPC for batch imports and offers gRPC search experimentally. Weaviate’s own engineering benchmarks, so treat them as vendor numbers, claim 60-80% faster batch imports and 40-70% faster query round-trips versus the legacy REST plus GraphQL path.

GraphQL remains available, and reviewers flag its learning curve as steep. G2 reviewers also report some client SDKs lagging the core feature set, forcing fallbacks to raw REST calls.

The scar is the v4 Python client. The rewrite changed the constructor (weaviate.Client() became connection helpers), the query interface (client.query.get() became collection-based queries), and the entire filter syntax, and it dropped every line of v3 compatibility while requiring a server at 1.23.5 or newer. One production team’s published account says Weaviate “lasted two projects” before they moved on, naming the schema-first design, the client rewrite, and GraphQL verbosity together.

Adopting today on v4 plus gRPC is a materially better experience than that history suggests. But the history is why version pinning and reading changelogs before every upgrade are non-optional practices here, not paranoia.

Self-Hosting Weaviate: The Real Operational Bill

Identical client code runs against a self-hosted cluster and Weaviate Cloud, which makes the exit path real: you can leave the managed service without rewriting your application. Pinecone offers no equivalent at any price.

Weaviate Community Forum threads and a GitHub issue document what self-hosting costs at scale:

• 130 GB of memory at 60 million objects, even with the vector cache capped at 1 million objects
• 70% of 128 GB consumed after a version upgrade from v1.18 to v1.25, reported as unexpectedly high
• 3-5 GB of daily memory growth after enabling the S3 backup module, with spikes to 10 GB
• 5-15 second cold queries and 3-4 second warm queries at 18 million objects, per a GitHub issue filed against v1.24.4

Self-hosting removes the license cost but moves memory tuning, scaling, backups, and upgrades onto your team. The deployment path is standard: Docker Compose for development, then Kubernetes at v1.23 or later with Helm v3 and ReadWriteOnce PersistentVolumeClaims for production. Budget for third-party observability too: G2 reviewers specifically ask for more built-in monitoring and visualization of cluster performance so they can stop relying on outside tools.

The honest split: under a few million vectors, self-hosting Weaviate is a single-node Docker job with little to operate. At tens of millions of objects it becomes a capacity-planning discipline, with forum reports showing a 100-GB-plus RAM appetite, and Flex’s $45 floor starts looking cheap against the engineer-hours you would spend tuning memory instead of shipping features.

How Does Weaviate Compare to Competitors?

Every serious Weaviate alternative wins a niche Weaviate does not. Match your workload to the niche and the choice mostly makes itself:

• Pinecone is the zero-ops path: serverless, scaling to billions of vectors with sub-20-30ms p95 latency and no servers to provision. Its Starter tier includes 2 GB of storage, 2 million write units, and 1 million read units a month. The costs climb sharply at scale (roughly 3-8x Postgres with pgvector at equivalent vector counts, per one practitioner comparison), and there is no self-host option at any price
• Qdrant is the price-performance pick for self-hosting: millions of vectors on a $30-50/month VPS, with in-graph payload filtering that applies metadata conditions during HNSW traversal instead of after it. Its perpetual free tier (0.5 vCPU, 1 GB RAM) needs no card, but its multi-tenancy is manual compared to Weaviate’s native isolation
• Milvus / Zilliz Cloud owns the 100-million-plus vector tier, with GPU acceleration and native Kafka and Spark integration. Reddit’s engineering team ran a 340-million-vector bake-off and chose Milvus over Qdrant; Weaviate was not in that contest, which tells you where it does not usually compete. Below roughly 50 million vectors, Milvus’s distributed mode, with its separate metadata, object storage, and message-log dependencies, is usually overkill
• pgvector is the default for teams already on Postgres with under roughly 2 million vectors: no new service, vectors in the same transaction as relational data, plain SQL. Past 2 million vectors, index builds stretch beyond 20 minutes and p95 latency climbs to 80-140ms at 5 million
• Elasticsearch fits teams already standardized on it for keyword search and logs who want vectors bolted on. It is keyword-first with kNN added, the inverse of Weaviate’s vector-first architecture

The honest criterion, echoed by the production team quoted earlier: a greenfield, text-only RAG project usually should not pick Weaviate. Multimodal retrieval and many-tenant SaaS usually should.

How We Test Vector Databases

We combine independent analysis, data collection, and hands-on testing: we set the tool up ourselves, run a real workload end to end, and compare it directly against its closest rivals. We collect public adoption and momentum signals from GitHub, PyPI, Docker Hub, Stack Overflow, G2, and Gartner peer reviews, we weigh sustained user sentiment across those platforms, and we hand-check every vendor pricing page rather than repeating published figures. Prices current as of September 2026.

Where an area cannot be measured for a tool, we mark it N/A rather than scoring it zero. Review-site sentiment is deliberately weighted small. Signals are refreshed monthly, editorial verdicts quarterly, and sponsors and affiliates cannot change a score.

Weaviate Review: Should You Build Your Search Stack on Weaviate?

We recommend Weaviate for three workloads it wins on merit: products that live or die on hybrid search quality, text-plus-image retrieval through the CLIP and ImageBind modules, and multi-tenant SaaS that needs per-tenant shard isolation at 50,000-plus shards per node. Teams taking it on should be able to absorb the schema ceremony and hold version discipline, because both are permanent features of the platform, not growing pains.

Skip it for text-only RAG under a few million vectors, where pgvector or Qdrant deliver with less machinery. Skip self-hosting without a real DevOps function, and use Flex instead. And if procurement needs stable published pricing, note plainly that Weaviate’s cloud tiers have been restructured more than once in a year.

The evaluation costs you one afternoon: create a free cluster (100,000 objects, no card), load a slice of your own corpus with the v4 client, and run one hybrid query against your ugliest real search phrase. That result will tell you more than any review, including this one.

FAQ

Is Weaviate free?

The database itself is free under the BSD-3-Clause license, with no fee for commercial self-hosting. Weaviate Cloud’s Free tier is also always free: 100,000 objects, 1 GB memory, 10 GB disk, and 3 tenants, no credit card required. Paid cloud plans start with Flex at $45/month.

Is Weaviate worth it compared to just using pgvector?

Only if you need what pgvector lacks: fused hybrid search, built-in multimodal vectorizer modules, or native multi-tenancy. For greenfield, text-only RAG under a few million vectors, practitioner comparisons favor pgvector, which avoids running a new service. See How Does Weaviate Compare to Competitors? above.

Do I have to use GraphQL to query Weaviate?

No. Weaviate exposes REST, GraphQL, and gRPC, and gRPC (stable since v1.23.7) is the default in the Python, TypeScript, Java, and C# clients. It is also the fastest path: 60-80% quicker batch imports per Weaviate’s benchmarks. GraphQL remains available, but reviewers flag its learning curve as steep.

How much does Weaviate Cloud cost?

As of September 2026: Free at $0 (100,000 objects, 3 tenants), Flex from $45/month pay as you go ($0.00465 per 1 million dimensions, $0.12/GiB storage, 99.5% SLA), and Premium at custom quotes, up to 99.95% SLA. Older articles print different tier names and prices, so confirm against the live pricing page before budgeting.

Can I self-host Weaviate to avoid cloud costs entirely?

Yes, via Docker Compose for development or Kubernetes with Helm v3 for production, with zero license cost. The trade is operational: memory tuning, backups, and upgrades land on your team, and a forum report of 130 GB memory at 60 million objects shows the burden is real at scale. See Self-Hosting Weaviate above.