Chroma Cloud, the hosted version of Chroma, is shutting down. According to Chroma's own notice, it becomes read-only on December 7, 2026 and stops serving read requests on December 22, 2026, so any data you want to keep must be exported and validated before then. Open-source ChromaDB is not affected, which means you can keep your application code almost unchanged by moving to a self-hosted Chroma server, or you can move to another vector store.
Who this is for and what you will have at the end
This guide is for developers and small teams who use Chroma Cloud for retrieval-augmented generation (RAG), semantic search or agent memory and need a practical plan before the deadlines. If you only use Chroma locally with PersistentClient, or you already run your own Chroma server, nothing here forces you to act.
By the end you will know which dates apply to you, how to confirm that you are actually on Chroma Cloud, how to export your collections two ways, how to choose a destination, and how to verify and cut over safely. The guide is deliberately neutral about where you go next; each option lists its own documented trade-offs.
The dates that matter
Chroma published its notice on October 23, 2026 at trychroma.com/cloud-wind-down. It describes a 60-day wind-down with two cutoffs:
| Date | What happens | Source wording |
|---|---|---|
| December 7, 2026 | Writes stop | Chroma Cloud "will become read-only" |
| December 22, 2026 | Reads stop | Cloud "will no longer serve read requests" |
Be careful with older coverage. Some third-party guides, including one from a vendor that wants your migration, say that writes stop on November 22, 2026. Chroma's page on the day we checked says December 7. If you read a different date somewhere, treat Chroma's page as authoritative and re-open it before finalizing your plan, because a vendor can revise a timeline.
Chroma's page also gives a short checklist:
- Before December 7: stop or redirect workloads that write to Chroma Cloud, move active workloads to another Chroma deployment or database, and start exporting and validating the data you need.
- Before December 22: finish exporting, confirm migrated applications no longer call Chroma Cloud endpoints, and remove or rotate Chroma Cloud credentials in your applications and infrastructure.
The page does not say what happens to Chroma's hosted embedding service, and it does not link to specific export guides. For account-specific questions it points to [email protected]. Because the embedding service is not mentioned, do not assume anything about it: if your collections rely on a Chroma-hosted embedding function, plan to embed with a model you control.
Check whether you are affected
Look for these signs in your code and infrastructure:
chromadb.CloudClient(...)in Python, or the Chroma Cloud endpointapi.trychroma.comin configuration.- Environment variables named
CHROMA_API_KEY,CHROMA_TENANTorCHROMA_DATABASE. Chroma's client docs say that with these three set you can callchromadb.CloudClient()with no arguments, so the connection may not be visible in the code. - A regional host such as
europe-west1.gcp.trychroma.compassed ascloud_host.
You are not affected if you use chromadb.PersistentClient(path=...) or connect to a server you host yourself. Search your repositories, secret stores and CI variables for the names above, because a forgotten staging service or a notebook is the usual source of a surprise after the cutoff.
Prerequisites
- A Chroma Cloud API key plus your tenant ID and database name.
- Python with the
chromadbpackage for the scripted export, or the Chroma CLI for the copy command. - Disk space for a full copy of your vectors, documents and metadata, and the ability to run Docker if you choose a self-hosted target.
- Your embedding model name and the vector dimension for each collection. Write these down now, because you need them after the move.
Step 1: Take an inventory of your collections
For each collection, record the name, the record count, the embedding dimension, the distance space, and the metadata keys you filter on. Chroma's Configure Collections page covers index settings and embedding functions, and the Python collection reference lists the methods. The inventory matters later because a destination may not copy the distance metric for you.
The distance space matters most. Qdrant's migration documentation states that its tool does not read the source collection's distance function and defaults to euclid, which it says matches Chroma's default l2. If your Chroma collection uses cosine or inner product you must set the metric explicitly. Zilliz's guide says the same thing in different words: the index metric (COSINE, L2, IP) is set when the index is built and is not copied.
Step 2: Export your data
Pick one of the two documented routes. Do both for anything business critical so you have a copy that does not depend on the destination.
Option A: Copy to a local Chroma server with the CLI
Chroma's CLI documents a copy command that moves collections between Chroma Cloud and a local server. The documented Cloud-to-local forms are:
chroma copy --from-cloud collections col-1 col-2
chroma copy --from-cloud --all --db my-db
chroma copy --from-cloud --all --host http://localhost:8050
chroma copy --from-cloud --all --path ~/Developer/my-app/chroma--db is the name of the Chroma Cloud database; if you leave it out, the CLI prompts you to pick one from the databases on your active profile. --host points at a local server and --path points at local Chroma data. The documentation says the CLI looks for a local server at localhost:8000 by default. The page documents authentication only as the "active profile", so sign in with the CLI first. This route leaves you with a regular Chroma data directory, which is what a self-hosted server reads.
Option B: Page through each collection and write a file
If you want a portable copy, or you plan to load a different database, read the collection in pages. Chroma's query and get documentation shows pagination with collection.get(limit=100, offset=0) and an include list. By default .get returns documents and metadatas, so ask for embeddings explicitly. Qdrant's migration documentation says Chroma Cloud returns at most 300 records per request, so keep your page size at 300 or lower.
import json
import chromadb
client = chromadb.CloudClient(
tenant="YOUR_TENANT_ID",
database="YOUR_DATABASE",
api_key="YOUR_CHROMA_API_KEY",
)
PAGE = 200
for col in client.list_collections():
name = col.name if hasattr(col, "name") else str(col)
collection = client.get_collection(name)
total = collection.count()
offset = 0
with open(f"{name}.jsonl", "w", encoding="utf-8") as out:
while offset < total:
page = collection.get(
limit=PAGE,
offset=offset,
include=["documents", "metadatas", "embeddings"],
)
for i, rec_id in enumerate(page["ids"]):
out.write(json.dumps({
"id": rec_id,
"document": page["documents"][i],
"metadata": page["metadatas"][i],
"embedding": [float(x) for x in page["embeddings"][i]],
}) + "\n")
offset += PAGE
print(name, total, "records exported")The CloudClient arguments (tenant, database, api_key) and the get call with limit, offset and include follow Chroma's documentation. The surrounding loop is our own glue code and has not been run. Writing one JSON object per line keeps memory use flat and lets you stream the file into most loaders. Compare the number of lines in each file with collection.count() before you trust the export. Because writes stop on December 7, the data will not change after that date, so a second export gives you a clean final copy.
Do not leave the API key in a shared notebook, and do not commit it. You only need the key until your final export, and Chroma's checklist asks you to rotate it afterward.
Step 3: Choose where to go
You have several families of destination. None is the single right answer. The right one depends on how much you want to operate yourself and how much of your application code can change.
| Option | Code change | You operate it | Documented notes |
|---|---|---|---|
| Self-hosted open-source Chroma | Smallest: new client and host | Yes | Apache 2.0, Docker image and persistent volume documented |
| Qdrant (self-hosted or Qdrant Cloud) | New client and query code | Optional | Migration tool copies vectors, text and metadata |
| Zilliz Cloud (managed Milvus) | New client and query code | No | Migration Service in the console, Vector Transport Service for private Chroma |
| PostgreSQL with pgvector | New client, SQL queries | Yes, or managed Postgres | Keeps vectors next to relational data |
Self-hosted Chroma
This keeps your data model and client API. Chroma's Docker page documents a single command:
docker run -v ./chroma-data:/data -p 8000:8000 chromadb/chromaData is stored in ./chroma-data on the host, and the server listens on port 8000. Connect with chromadb.HttpClient(host='localhost', port=8000) and confirm with heartbeat(). Chroma also has deployment guides for AWS, Azure and GCP. The Docker page contains no production hardening advice, so plan your own backups, authentication, TLS and network isolation. The trade-off is that you now carry the operations work that Chroma Cloud used to do.
Qdrant
Qdrant publishes a migration page for Chroma and an image that copies a collection. For a Chroma Cloud source the documented settings are the URL https://api.trychroma.com together with tenant, database, token authentication and the token header X-Chroma-Token:
docker run --rm -it registry.cloud.qdrant.io/library/qdrant-migration chroma \
--chroma.url 'https://api.trychroma.com' \
--chroma.tenant 'YOUR_TENANT_ID' \
--chroma.database 'YOUR_DATABASE' \
--chroma.auth-type token \
--chroma.token-header X-Chroma-Token \
--chroma.token 'YOUR_CHROMA_API_KEY' \
--chroma.collection 'your-collection' \
--qdrant.url 'https://your-instance.cloud.qdrant.io:6334' \
--qdrant.api-key 'YOUR_QDRANT_API_KEY' \
--qdrant.collection 'your-collection' \
--qdrant.distance-metric cosine \
--migration.batch-size 300Qdrant's page says to keep --migration.batch-size at 300 or lower. Each Chroma collection becomes a Qdrant collection, each record becomes a point, embeddings become vectors, metadata becomes the payload, and the document text goes into a payload field (document by default). The distance flag defaults to euclid. The example sets cosine only as an illustration, so replace it with the metric your collection really uses. This exact command is assembled from the documented flags and was not run.
Zilliz Cloud (managed Milvus)
Zilliz's guide describes a free Migration Service in its console for Chroma Cloud or an internet-reachable self-hosted server, and a Vector Transport Service (an open-source Docker image driven by a config file) for private or embedded Chroma. Its concept mapping is useful on any move: a collection keeps its name with - converted to _, the id becomes a VARCHAR primary key, the embedding becomes a FLOAT_VECTOR field of the same dimension, metadata goes into a dynamic field, and where filters become filter expressions.
It also lists caveats worth reading before you start. Empty collections are skipped, collection names with dots or a leading digit need renaming, rerunning the transport service into the same collection duplicates records, and cosine or inner-product collections return similarity (higher is better) rather than Chroma's distance (lower is better), so score thresholds must be inverted.
PostgreSQL with pgvector
If your application already uses Postgres, keeping vectors in the same database can remove a service. You would load the exported JSONL into a table with a vector column and build an HNSW or IVFFlat index. See our guide to tuning pgvector HNSW and IVFFlat indexes and the comparison in pgvector vs Azure AI Search vs Qdrant. Expect to rewrite query and filter code, because Chroma's where syntax becomes SQL.
Other managed vendors
Some vendors have promoted offers to Chroma Cloud users. We did not verify any such offer in this run, so check the vendor's own pricing and migration pages directly and compare on the same criteria: price at your data size, filtering support, region, export options and contract terms.
Step 4: Keep the embeddings consistent
A vector store holds numbers, not the model that produced them. Zilliz's guide says the embedding function is not stored and your application must embed queries. If you copy vectors, you must embed new queries with the same model, version and dimension that created them. Chroma's add-data documentation notes that embeddings whose dimensionality does not match the collection raise an exception, and other databases behave similarly.
If you want to change models during the move, re-embed all documents from your original source text instead of copying vectors. Our guide on embedding model dimensions, cost and chunking covers that decision. Re-embedding needs your source documents, so make sure the exported document field is complete before Chroma Cloud goes dark.
Step 5: Verify the migration
Do not cut over on a successful copy message alone. Run these checks on every collection:
- Compare record counts between the source and the destination.
- Pick 20 to 50 real queries. Run each against both systems and compare the top 10 results. Zilliz's guide recommends a top-10 overlap check and notes that low overlap usually means the index metric does not match the distance space.
- Spot check the metadata filters you actually use, since filter syntax differs between databases.
- Test score thresholds. If you filter on a distance cutoff, remember whether the new system returns distance or similarity.
- Compare latency under your normal query load, not a single query.
Step 6: Cut over
A safe order, adapted from the vendor guidance above:
- Do a first full copy while Chroma Cloud still accepts writes.
- Pause or redirect writes to Chroma Cloud before December 7, and make the application write to the new store.
- Run a final copy of anything written since the first copy, then re-check record counts.
- Deploy the application pointed at the new store and watch error rates.
- Search the codebase and infrastructure for any remaining Chroma Cloud endpoint and remove it.
- Remove or rotate the Chroma Cloud API key everywhere, as Chroma's checklist asks, and keep the exported files in encrypted storage for a retention period you choose.
Finish all of this before December 22, because there is no read access after that date.
Troubleshooting
| Symptom | Likely cause | Fix |
|---|---|---|
| Export stops with an error on a large page | Page size above the Cloud limit | Use a page size of 300 or lower |
| Search results differ after the move | Wrong distance metric on the destination | Rebuild the index with the metric the Chroma collection used |
| Dimension mismatch exception | Queries embedded with a different model | Use the original model or re-embed everything |
| Duplicate records after a second run | Loader appends to an existing collection | Drop the target or use a new collection name |
| Collection missing in the destination | Empty collection or invalid name | Add a record or rename it, per the vendor's caveats |
| Old application still returns data after cutover | It still reads from Chroma Cloud | Search for the endpoint and the three CHROMA_ variables, then rotate the key |
Pre-deadline checklist
- Confirm you use Chroma Cloud and list every collection.
- Note each collection's distance space, dimension and embedding model.
- Export twice: once now, once after writes stop.
- Pick a destination and test it on your own queries.
- Verify counts and top-10 overlap, then cut over.
- Remove Chroma Cloud endpoints and rotate credentials before December 22, 2026.
What we checked
- Opened Chroma's wind-down page on 2026-11-21: writes stop December 7, 2026 (Cloud becomes read-only), reads stop December 22, 2026, open-source Chroma stays under Apache 2.0, and the page does not mention the hosted embedding service.
- Compared that with a Zilliz guide that quotes November 22, 2026 for writes stopping. The two disagree, so this article uses Chroma's own dates.
- Opened Chroma's query-and-get docs and confirmed
collection.get(limit=100, offset=0), theincludelist, and that.getreturns documents and metadatas by default. - Opened Chroma's client docs and the CLI copy page and confirmed the
CloudClientarguments and thechroma copy --from-cloudforms quoted above. - Opened Qdrant's Chroma migration page and confirmed the Docker image, the flags in the example, the 300-record batch limit and that the tool does not read the source distance function.
- Opened Zilliz's migration guide and confirmed the concept mapping and caveats quoted above.
- Not tested hands-on: we had no Chroma Cloud account, and we did not run the export script or any migration tool. The script is our own glue code around documented calls.
Last tested: 2026-11-21
References
- Chroma Cloud wind-down notice: https://www.trychroma.com/cloud-wind-down
- Chroma docs, query and get: https://docs.trychroma.com/docs/querying-collections/query-and-get
- Chroma docs, clients: https://docs.trychroma.com/docs/run-chroma/clients
- Chroma docs, add data: https://docs.trychroma.com/docs/collections/add-data
- Chroma docs, copy collections (CLI): https://docs.trychroma.com/docs/cli/copy
- Chroma docs, Docker: https://docs.trychroma.com/guides/deploy/docker
- Qdrant, migrate from Chroma: https://qdrant.tech/documentation/migrate-to-qdrant/from-chroma/
- Zilliz, how to migrate from Chroma to Zilliz Cloud: https://zilliz.com/blog/how-to-migrate-from-chroma-to-zilliz-cloud
Comments
Questions and tips are welcome. Comments are checked by the EpiFive team before they appear; please do not share passwords, phone numbers or other private details.