Beginner’s Guide to Qdrant: Getting Started in 2026

This guide covers how to get started with Qdrant for beginners who are building AI/RAG apps and need real limits and numbers, not marketing fluff. Qdrant’s free tier is worth it for prototyping RAG — you get a real vector database with community support and no credit card.

How This Guide Was Built

This guide is based on the official Qdrant documentation, the Qdrant pricing page, and community reports — we did not run the tool hands-on. What was verified: free tier limits, the signup flow, and first-project steps (collection creation, upsert, query). What was NOT tested: production-scale workloads and high-availability setups — those steps are based on official docs only. Last verified: August 2026.

What is Qdrant and why should indie hackers care?

Qdrant is an open-source (Apache 2.0) vector search engine written in Rust, used for semantic search, recommendations, and RAG pipelines. It lets you store embeddings and run similarity searches with filters — the core of most AI apps today. For indie hackers, it matters because it ships a generous free tier and a local Docker option, so you can build and ship a real vector database without spending money.

Most indie hackers hit the wall when their prototype outgrows SQLite or a simple in-memory list. Qdrant slots in as the next step: it handles vector math, payload filtering, and REST/gRPC APIs out of the box. You don’t need to manage indexing logic or worry about cosine distance bugs — Qdrant does that. And because it’s Rust-based, it’s fast enough for real queries on a 1GB RAM budget.

The free cloud tier is explicitly “for testing and prototypes,” which means it’s legit for side projects that haven’t monetized yet. You can also run it locally with one Docker command, matching our Qdrant directory entry notes on local-first development.

How do I get started with Qdrant?

You can start with Qdrant either on the free cloud tier or locally via Docker — both are production-compatible paths. Pick cloud if you want to skip setup, or local if you prefer full control over your dev environment.

Cloud free cluster (no credit card required):

1. Go to cloud.qdrant.io and create an account (email, Google, or GitHub).
2. Click “Create a free cluster” — you get a Single Node Cluster with 0.5 vCPU, 1GB RAM, and 4GB disk.
3. Once the cluster is ready, copy the cluster URL and API key from the dashboard.
4. Use them in your Python client: QdrantClient(url=CLUSTER_URL, api_key=API_KEY).

Local Docker (for development):

docker run -p 6333:6333 -p 6334:6334 \
  -v "$(pwd)/qdrant_storage:/qdrant/storage" \
  qdrant/qdrant

Then open http://localhost:6333/dashboard for the Web UI, or hit the REST API on :6333 and gRPC on :6334.

The local path is what the Qdrant quickstart documentation recommends for first-time users.

What are the free-tier limits?

The free cloud tier gives you a single node cluster with 0.5 vCPU, 1GB RAM, and 4GB disk, plus free cloud inference with selected models — enough for roughly 100K 384-dimension vectors based on community sizing reports. Exceeding 1GB RAM or 4GB disk requires an upgrade to the Standard Tier, per the Qdrant pricing page. Here is the breakdown:

Resource	Limit
vCPU	0.5
RAM	1GB
Disk	4GB
Nodes	Single node cluster
High availability	No
Support	Community (Discord)
Inference	Free Cloud Inference with selected models
Upgrade trigger	Exceeding 1GB RAM or 4GB disk

You can store roughly 100K vectors of 384 dimensions (all-MiniLM-L6-v2 class) comfortably within the 1GB RAM limit, based on community-reported sizing. Exceeding 1GB RAM or 4GB disk requires upgrade to the Standard Tier, per the Qdrant pricing page.

How do I build a simple vector search with the Python client?

You can build a working vector search in under 50 lines of Python using the qdrant-client library, which handles collection creation, upserts, and queries with a clean API. Install it with pip, connect to your local or cloud instance, and you’re ready to create collections, load vectors, and search with optional payload filters.

pip install qdrant-client

from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct, VectorParams, Distance, Filter, FieldCondition, MatchValue

# Connect (local or cloud)
client = QdrantClient(url="http://localhost:6333")
# Or for cloud: QdrantClient(url=CLUSTER_URL, api_key=API_KEY)

# Create collection
client.recreate_collection(
    collection_name="cities",
    vectors_config=VectorParams(size=384, distance=Distance.COSINE)
)

# Upsert points with payloads
client.upsert(
    collection_name="cities",
    points=[
        PointStruct(id=1, vector=[0.1]*384, payload={"city": "Berlin"}),
        PointStruct(id=2, vector=[0.2]*384, payload={"city": "Paris"}),
        PointStruct(id=3, vector=[0.3]*384, payload={"city": "Berlin"}),
    ],
    wait=True
)

# Query
hits = client.query_points(
    collection_name="cities",
    query=[0.15]*384,
    limit=3,
    with_payload=True
)
print(hits.points)

# Filtered query (only Berlin)
filtered = client.query_points(
    collection_name="cities",
    query=[0.15]*384,
    limit=3,
    with_payload=True,
    query_filter=Filter(must=[FieldCondition(key="city", match=MatchValue(value="Berlin"))])
)

Always use wait=True on upserts during development — it ensures the write is durable before you query. And make sure your embedding dimension matches the VectorParams(size=...) exactly, or Qdrant will reject the points.

One performance note: if you filter on a payload field (like city above), create an index on that field. Without an index, Qdrant scans the full collection for every filtered query — fine at 1K vectors, but sluggish as you approach 100K. Index it once with client.create_payload_index(collection_name="cities", field_name="city") and filtered queries stay fast as the collection grows. This matters more on the free tier, where you only have 1GB of RAM to work with and can’t throw hardware at the problem.

Common mistakes beginners make with Qdrant

1. Forgetting wait=True on upserts — you’ll query before data is flushed and get empty results.
2. Using the wrong distance metric — cosine is standard for sentence embeddings, but dot product or Euclidean will silently give bad results if your model expects cosine.
3. Ignoring the 1GB RAM limit during bulk upserts — loading 500K vectors at once will OOM your free cluster. Batch in chunks of 10K or less.
4. Mixing up Edge vs Cloud vs local Docker — Edge is embedded (not covered here), Cloud is managed, and Docker is local. Don’t try to use Cloud credentials against a local instance.
5. No payload indexing before filters — filtering on an unindexed payload field triggers a full scan. Create an index on frequently filtered keys like city or category.
6. Treating the free cluster like a production database — no snapshots automation and no high availability means a single bad migration can take your prototype down. Keep a copy of your embedding source data locally so you can rebuild a collection from scratch.

When should you upgrade from the free tier?

You should upgrade when you consistently exceed the 1GB RAM or 4GB disk limits, need high availability for production traffic, or require SLA-backed support. The free tier is explicitly for testing and prototypes — if your side project hits 10K+ daily active users with real-time queries, it’s time to move to Standard Tier. Our Meilisearch free tier guide and Upstash free tier guide cover similar upgrade signals for other tools if you’re comparing options.

FAQ

Is Qdrant free?

Yes, Qdrant’s cloud free tier is free forever for testing and prototypes, with no credit card required. You get 0.5 vCPU, 1GB RAM, and 4GB disk on a single node cluster. Community support is provided via Discord, and there’s no high availability. Exceeding 1GB RAM or 4GB disk requires upgrade to the Standard Tier, as listed on the Qdrant pricing page.

How many vectors can I store on the Qdrant free tier?

You can store roughly 100K vectors of 384 dimensions (all-MiniLM-L6-v2 class embeddings) comfortably within the 1GB RAM limit, based on community-reported sizing. If your vectors are larger or you need more headroom, you’ll hit the RAM ceiling faster and need to upgrade. This isn’t a hard limit set by Qdrant — it’s the physical constraint of your free cluster’s memory.

Do I need a credit card to use Qdrant Cloud?

No, you do not need a credit card to use Qdrant Cloud’s free tier. You can sign up at cloud.qdrant.io using email, Google, or GitHub, create a free cluster, and start building immediately. The free tier is explicitly labeled “for testing and prototypes” and includes community support via Discord. You only need payment details if you exceed 1GB RAM or 4GB disk and want to upgrade to the Standard Tier.

Can I move from the free tier to Standard later?

Yes. The Standard Tier is a paid upgrade that increases your cluster’s RAM and disk, and because it’s the same managed cloud, you scale the same cluster up instead of migrating data to a new one — no need to re-export and re-upload your vectors. Check the Qdrant pricing page for current Standard Tier limits. If you’d rather stay free, the local Docker option remains fully open-ended, with the only cost being your own machine’s resources.