Databases & HA

Chroma Cloud Shutdown: Key Dates, Export Your Collections, Migrate

Chroma Cloud goes read-only on December 7, 2026 and stops serving reads on December 22. How to export your collections and move to a self-hosted or managed vector store.

By EpiFive Editorial TeamReviewed/updated 14 min readHow we check our guides
On this page

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:

DateWhat happensSource wording
December 7, 2026Writes stopChroma Cloud "will become read-only"
December 22, 2026Reads stopCloud "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 endpoint api.trychroma.com in configuration.
  • Environment variables named CHROMA_API_KEY, CHROMA_TENANT or CHROMA_DATABASE. Chroma's client docs say that with these three set you can call chromadb.CloudClient() with no arguments, so the connection may not be visible in the code.
  • A regional host such as europe-west1.gcp.trychroma.com passed as cloud_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 chromadb package 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.

OptionCode changeYou operate itDocumented notes
Self-hosted open-source ChromaSmallest: new client and hostYesApache 2.0, Docker image and persistent volume documented
Qdrant (self-hosted or Qdrant Cloud)New client and query codeOptionalMigration tool copies vectors, text and metadata
Zilliz Cloud (managed Milvus)New client and query codeNoMigration Service in the console, Vector Transport Service for private Chroma
PostgreSQL with pgvectorNew client, SQL queriesYes, or managed PostgresKeeps 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/chroma

Data 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 300

Qdrant'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:

  1. Compare record counts between the source and the destination.
  2. 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.
  3. Spot check the metadata filters you actually use, since filter syntax differs between databases.
  4. Test score thresholds. If you filter on a distance cutoff, remember whether the new system returns distance or similarity.
  5. Compare latency under your normal query load, not a single query.

Step 6: Cut over

A safe order, adapted from the vendor guidance above:

  1. Do a first full copy while Chroma Cloud still accepts writes.
  2. Pause or redirect writes to Chroma Cloud before December 7, and make the application write to the new store.
  3. Run a final copy of anything written since the first copy, then re-check record counts.
  4. Deploy the application pointed at the new store and watch error rates.
  5. Search the codebase and infrastructure for any remaining Chroma Cloud endpoint and remove it.
  6. 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

SymptomLikely causeFix
Export stops with an error on a large pagePage size above the Cloud limitUse a page size of 300 or lower
Search results differ after the moveWrong distance metric on the destinationRebuild the index with the metric the Chroma collection used
Dimension mismatch exceptionQueries embedded with a different modelUse the original model or re-embed everything
Duplicate records after a second runLoader appends to an existing collectionDrop the target or use a new collection name
Collection missing in the destinationEmpty collection or invalid nameAdd a record or rename it, per the vendor's caveats
Old application still returns data after cutoverIt still reads from Chroma CloudSearch 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), the include list, and that .get returns documents and metadatas by default.
  • Opened Chroma's client docs and the CLI copy page and confirmed the CloudClient arguments and the chroma copy --from-cloud forms 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

Questions people ask

When does Chroma Cloud shut down?

Chroma's wind-down page, published October 23, 2026, says Chroma Cloud becomes read-only on December 7, 2026 and stops serving read requests on December 22, 2026. Some third-party guides still quote November 22 as the date writes stop, so use Chroma's own page as the source of truth and check it again before you plan a cutover.

Is open-source ChromaDB affected by the Chroma Cloud shutdown?

No. Chroma's page says open-source Chroma remains available under the Apache 2.0 license and that Replit will continue contributing to the project. Only the hosted Chroma Cloud service is winding down, so a self-hosted server or an embedded PersistentClient keeps working.

How do I export my data from Chroma Cloud?

Chroma's CLI has a copy command that can copy collections from Chroma Cloud to a local Chroma server, for example chroma copy --from-cloud --all. You can also page through a collection with collection.get using limit and offset and include embeddings, documents and metadata, then write the records to files or load them into another store.

Do I need to re-embed my documents when I migrate?

Not if you copy the stored vectors and keep using the same embedding model and dimensions for queries. The destinations below do not carry Chroma's embedding function with the data, so your application must embed queries with the same model. If you change models, you must re-embed everything.

ChromaChromaDBVector DatabaseQdrantMilvuspgvector