TL;DR: For a first RAG prototype, Pinecone gives 2 GB of storage, 2 million write units and 1 million read units a month. Qdrant gives a free cluster with 1 GB of RAM and 4 GB of disk. Weaviate gives 100,000 objects, but only one collection. If your app already needs Postgres, Neon gives 1 GB per project across 100 projects, and Supabase gives 500 MB with pgvector. Chroma starts you with $5 in credits, not a free cluster.
Two kinds of free vector tier
A vector database stores embeddings. These are long lists of numbers, one list per chunk of text, image or record. A query turns the question into the same kind of list. The database then returns the stored vectors that sit closest to it.
Free plans come in two kinds.
The first kind is a dedicated vector store. Pinecone, Qdrant, Weaviate and Chroma sell vector search as the product. You create an index or a collection, push vectors in and query them over an API. The free limit is usually a size cap or a request cap.
The second kind is Postgres with the pgvector extension. Neon, Supabase and Nile give you a
normal Postgres database. You add a vector column next to your other columns. You pay no
extra for the feature, but the free limit is the size of the whole database. Your users table
and your embeddings share the same 500 MB or 1 GB.
Neither kind is better in general. A dedicated store fits when the vectors are the main data. Postgres fits when the vectors belong to rows you already keep, such as a product, a ticket or a document with an owner.
All seven products below sit in the Vector Databases category or in a database category with pgvector support.
Comparison table
| Product | Free capacity | Compute | Request limit | Idle rule | First paid step |
|---|---|---|---|---|---|
| Pinecone | 2 GB storage, 5 indexes, 100 namespaces per index | 2M write units and 1M read units a month | Builder, $20 a month flat | ||
| Qdrant | 4 GB disk, single node | 0.5 vCPU, 1 GB RAM | Standard Tier, billed by resource use | ||
| Weaviate | 100,000 objects, 10 GB disk, 1 collection, 3 tenants | 1 GB memory | Embeddings 2,000 a day, Query Agent 1,000 a month | Flex, from $45 a month | |
| Chroma | $5 in credits, 10 databases | Team, $250 a month plus usage | |||
| Neon | 1 GB per project, 100 projects | 100 CU-hours per project, up to 2 CU (8 GB RAM) | Compute scales to zero after 5 minutes idle | Launch, billed by usage | |
| Supabase | 500 MB database, 2 active projects | Shared CPU, 500 MB RAM | Projects pause after 1 week of inactivity | Pro, from $25 a month | |
| Nile | 1 GB storage | 50 million query tokens | No pauses | Pro, $15 a month |
Weaviate’s free plan needs no credit card, and so does Neon’s.
Pinecone
Pinecone’s Starter plan is the most complete free quota in this group. It gives you up to 2 GB of storage, up to 2 million write units and up to 1 million read units a month. You can create up to 5 indexes, with up to 100 namespaces in each one.
Namespaces are easy to overlook. A namespace is a partition inside an index. If you build a product where each customer gets a private knowledge base, you can map one customer to one namespace. The free plan allows 100 of them in one index.
Write and read units are not the same as requests. A write unit is spent when you upsert vectors. A read unit is spent when you query. Pinecone’s pricing page shows example workloads, so test your real batch sizes before you trust a monthly total.
The first paid step is Builder at $20 a month flat. After that, Standard starts at a $50 a month minimum, then usage billing applies. See the Pinecone listing for the full list of what the free plan includes.
Qdrant
Qdrant gives you one free cluster with a single node. The node has 0.5 vCPU, 1 GB of RAM and 4 GB of disk. The plan has no stated limit on requests, so the cap is the hardware.
You do not count units here. You watch memory. A collection that keeps all its vectors in RAM will fill 1 GB quickly. Qdrant lets you keep vectors on disk, which is how you use the full 4 GB. The query is slower, but the data fits.
Qdrant’s free plan also includes free cloud inference with selected models. That means you can send text to the cluster and let it create the embeddings. For a small prototype, this removes one separate API key from your setup.
The free tier has no high availability. Qdrant says it is meant for testing and prototypes. When you outgrow it, you move to the Standard Tier, where you pay for the vCPU, memory and storage that you use. See the Qdrant listing.
Weaviate
Weaviate’s free plan is called Free Forever. It costs $0 and needs no credit card. You get one cluster per user with 100,000 objects, 1 GB of memory and 10 GB of disk.
Two caps matter most: 1 collection and up to 3 tenants. If your design uses one collection per data type, you hit the cap on day one. You can merge the types into one collection with a property that tells them apart.
Embeddings are free up to 2,000 requests a day. The Query Agent is free up to 1,000 requests a month. The Query Agent turns a plain-language question into a search for you.
When you need more, Flex starts at $45 a month. See the Weaviate listing, and the Weaviate alternatives page if the one-collection cap is too tight.
Chroma
Chroma is the odd one in this table, because its Starter plan is credits, not a free cluster. Starter costs $0 a month plus usage, and it starts with $5 in credits. It allows up to 10 databases and 10 team members.
The usage prices are listed on Chroma’s pricing page. Storage costs $0.33 per GB per month. Writing data costs $2.50 per GB written. Queries are billed by the terabyte queried and the gigabyte returned. Once the $5 is gone, you pay these rates.
The next step is Team, at $250 a month plus usage, with $100 in credits included. See the Chroma listing.
Neon
Neon is serverless Postgres, and pgvector is one of its supported extensions. The free plan has no time limit and needs no credit card. You can create 100 projects. Each project gets 100 CU-hours of compute a month, up to 2 CU, which is 8 GB of RAM, and 1 GB of storage.
Compute scales to zero after 5 minutes without queries. The first query after that starts it again. The page says this takes a few hundred milliseconds. Your data and connection string stay the same.
The 100-project limit gives you a pattern that the dedicated stores do not. You can give each customer, or each experiment, a separate database. Each one has its own 1 GB.
The first paid plan is Launch, which bills by usage. See the Neon listing. It also sits in the Serverless Databases category.
Supabase
Supabase also runs on Postgres, and its documentation lists pgvector as a supported extension. The free plan gives you a 500 MB database on shared CPU with 500 MB of RAM. You can run 2 active projects.
The idle rule is the one that surprises people. Free projects pause after 1 week of inactivity. A demo that nobody opens for a week goes offline until you resume it.
The same free plan gives 50,000 monthly active users for authentication and 1 GB of file storage. If your RAG app also needs login and uploads, you configure one service, not three.
Pro starts at $25 a month. See the Supabase listing.
Nile
Nile is a Postgres database built for apps that serve many tenants. Its free plan gives 1 GB of storage and 50 million query tokens. Query tokens are Nile’s unit for the CPU and memory that your queries use. The plan says it has no pauses and stays always available.
Nile works well when each of your customers needs separate data and vectors. Additional query tokens cost $0.06 per million on the free plan’s rate, and extra storage costs $1.50 per GB. Pro costs $15 a month. See the Nile listing.
A worked example: 100,000 chunks
Take a documentation site with 100,000 text chunks. You embed each chunk with a model that returns 1,536 numbers per vector.
A vector with 1,536 numbers stored as 32-bit floats takes 1,536 × 4 = 6,144 bytes. Multiply by 100,000 chunks and you get about 614 MB for the raw vectors. That excludes the text of the chunks, any metadata and any search index. Use that number to check each plan.
- Pinecone: 614 MB fits in 2 GB. The open question is write units. Load the data in batches and check the console.
- Qdrant: 614 MB fits on the 4 GB disk. It is more than half of the 1 GB of RAM, so keep the vectors on disk and leave the RAM for the index.
- Weaviate: 100,000 objects is exactly the cap. One more object breaks the plan. If you plan to add pages later, you start with no room.
- Chroma: Writing 0.614 GB at $2.50 per GB costs about $1.54. Storing it costs about $0.20 a month at $0.33 per GB. The $5 credit covers the load and a few months of storage. Query fees come on top.
- Neon: 614 MB fits in the 1 GB project before you add an index. A vector index takes extra space, so the total can pass 1 GB. Use a second project or drop to 768 dimensions.
- Supabase: 614 MB is more than the 500 MB database. It does not fit as it stands. Cut the dimensions in half, or pick another plan.
- Nile: 614 MB fits in 1 GB, with less than 400 MB left for everything else.
At 768 dimensions the raw vectors take about 307 MB, which fits all seven plans. On Supabase that leaves about 190 MB for everything else.
Which one to pick
Pick Pinecone if you want a hosted index with clear quotas and you do not want to run anything. Pick Qdrant if you prefer fixed hardware to unit counting, and you can keep vectors on disk.
Pick Weaviate if your data fits one collection and under 100,000 objects. Do not start there if you need several collections.
Pick Neon if the vectors belong with relational data, and you want a database per customer. Pick Supabase if you also need auth and file storage, and you accept the weekly pause. Pick Nile if you are building a multi-tenant app.
Pick Chroma if you want to try the API and expect to pay a few dollars a month anyway.
For a wider view of free databases that are not vector stores, see Relational Databases and the best free database tiers article.