Databricks Vector Search vs Snowflake Cortex Search vs Vertex AI Vector Search: Real Managed RAG Cost at 100 Million Vectors in 2026

The short answer: these three managed vector-search products bill in three completely different units — Databricks by DBU-hours per capacity "unit," Snowflake by gigabytes of indexed data per month, and Vertex AI by node-hours for the compute serving the index — and none of them makes it simple to project cost at real production scale. At 100 million vectors (768 dimensions), Databricks Vector Search costs about $10,080 a month in US East (or $12,672 in AP Sydney, a real regional price difference for identical service), Snowflake Cortex Search costs about $5,032 a month on the global AI Credit rate (or $5,535 regional), and Vertex AI Vector Search's cost at this scale cannot be confidently derived from public information — Google's own worked examples only cover small indexes (a single node serving 10,000 records at about $548/month), and scaling to 100 million vectors requires a node/shard count that Google's documentation does not publish as a simple formula.

What each vendor bills

Databricks Mosaic AI Vector Search (OFFICIAL, Databricks Vector Search pricing). Priced in capacity units, each covering up to 2 million vectors at 768 dimensions, billed at 4 DBU per hour per unit, and DBU-hour cost varies by region: $0.070/DBU in US East, working out to $0.28/hour/unit, versus $0.088/DBU in AP (Sydney), $0.352/hour/unit — a 26% regional premium for identical service. Databricks' own published worked example: 10 million vectors, 5 units, 720 hours a month, comes to 14,400 DBUs and $1,008/month in US East, or $1,267/month in AP Sydney for the same workload.

Snowflake Cortex Search (OFFICIAL for the credit currency, confirmed directly against Snowflake's current AI pricing documentation). Snowflake's own documentation now explicitly lists Cortex Search (and Cortex Batch Search) as AI Credit priced, the same flat, edition-independent currency as Cortex Agents and AI Functions — $2.00 per credit for global routing, $2.20 for regional. Five separate billing components make up a Cortex Search bill: serving compute at 6.3 AI Credits per GB of indexed data per month, billed continuously whether or not anyone queries the index; embedding tokens at model-specific rates during indexing (a cheap embedding model like snowflake-arctic-embed-l-v2.0 was reported at 0.05 credits per million tokens); standard warehouse compute (billed separately, in Platform Credits) for materializing and refreshing search data; storage at Snowflake's standard per-TB rate; and cloud services, usually free unless exceeding 10% of daily warehouse usage. An older worked example priced a 100 GB index at 630 credits a month using a pre-2026 $3/credit edition rate — that $3 figure describes the legacy Platform Credit era and is now superseded by the flat $2.00/$2.20 AI Credit rate confirmed above.

Vertex AI Vector Search (OFFICIAL for the mechanism, REPORTED for a small-scale worked example only). Infrastructure-based: you pay for compute nodes hosting your vector index, billed per node-hour, with cost depending on machine type, index size, and replica count. A documented small-scale example: 10,000 records (768-dim, about 0.0286 GiB), served on a single e2-standard-16 node at roughly $0.75/hour, comes to about $547.50/month, plus a one-time index-building cost of $3 per GiB of indexed data each time the index is rebuilt or updated. Independent hidden-cost analysis separately reports that "a moderately sized index on three replicas runs roughly $700–$800/month" — a REPORTED range, not tied to a specific vector count. Neither figure scales cleanly to 100 million vectors: Google's documentation does not publish a simple formula for how many nodes or shards a given vector count and query-throughput requirement needs, so an accurate quote at this scale requires either Google's own sizing calculator or a direct conversation with Google Cloud.

Cost at 100 million vectors (768 dimensions)

Formula: Databricks = units required × 4 DBU/hour × hours/month × $/DBU, where units required = vectors ÷ 2,000,000; Snowflake = indexed GB × 6.3 credits/GB × $/credit, with indexed GB estimated at raw bytes (vectors × dimensions × 4 bytes) times an ILLUSTRATIVE 1.3x index-overhead multiplier, consistent with this site's companion vector-database-cost article; Vertex = QUOTE-ONLY / UNKNOWN at this scale, since no public sizing formula was found.

None of these figures include the underlying embedding-generation cost (covered separately in this site's companion embedding-cost article), the LLM generation call that typically follows a retrieval (covered in the batch and managed-RAG comparisons), or standard warehouse/compute charges layered on top, which continue to bill separately in Platform Credits regardless of the AI Credit pricing applied to the AI-specific components above.

The regional price gap that isn't about the model

On Databricks specifically, the exact same vector-search service, at the exact same vector count, costs 26% more in AP Sydney than in US East, purely because of a higher DBU rate in that region — a cost driver with nothing to do with data volume, query pattern, or index configuration, and one a team choosing a non-US-East region for latency or data-residency reasons should budget for explicitly.

Why Vertex AI's cost cannot be confidently scaled here

The only fully worked Vertex AI Vector Search example found in the sources reviewed served 10,000 vectors on a single node. Scaling to 100 million vectors — 10,000 times that volume — almost certainly requires many more nodes, likely with sharding and replication for both capacity and query throughput, but Google's public documentation does not publish the underlying sizing rules (vectors per node, queries-per-second per node, or a similar capacity formula) needed to project the node count, and therefore the cost, at this scale with any confidence. The separately reported "$700–$800/month for a moderately sized index" figure is not tied to a specific vector count in its source and should not be treated as this article's 100-million-vector answer.

Sensitivity

1. Region choice, on both Databricks and Snowflake. A confirmed 26% cost difference between US East and AP Sydney on Databricks, and a 10% difference between global and regional AI Credit routing on Snowflake (6.3 credits/GB at $2.00 versus $2.20).
2. Index-overhead multiplier. This article's 1.3x assumption for both Snowflake's GB-based billing and Vertex's GiB-based build cost directly scales the resulting dollar figures; a different overhead ratio changes both proportionally.
3. Vertex AI's actual node/shard requirement at scale. The single largest unresolved variable in this article; only a vendor sizing calculator or direct conversation can produce a confident number.
4. Embedding model choice on Snowflake. A cheap embedding model versus a more capable one changes the indexing-time cost component, separate from the ongoing serving-compute charge.

Budgeting traps

• Budgeting Snowflake Cortex Search off an older, pre-2026 Platform Credit rate. Snowflake's current documentation confirms Cortex Search bills in the flat $2.00/$2.20 AI Credit currency; an older $3-per-credit figure reflects the superseded edition-priced model.
• Ignoring regional DBU-rate differences on Databricks Vector Search. The same service, same vectors, same query pattern costs materially more outside US East.
• Extrapolating a small-scale Vertex AI Vector Search example to a large production index. A single-node example serving 10,000 records does not predict the node count, and therefore the cost, at 100 million vectors.
• Forgetting Cortex Search's continuous, query-independent billing. Like Databricks' capacity-unit model, it accrues cost whether or not anyone is actively searching.

What to ask before you buy

For Vertex AI Vector Search at genuine production scale, request a sizing estimate directly from Google Cloud or use its own cost calculator rather than extrapolating from a small worked example, since no public formula connects vector count to required node count. Confirm your embedding model's per-token AI Credit rate directly against Snowflake's Service Consumption Table before budgeting the indexing-time cost component of a Cortex Search deployment.