Mem0 Pricing Explained: Tiers, What Is Metered, Free Tier and Alternatives

Mem0 pricing comes in two shapes. The hosted Mem0 Platform is free up to 10,000 add requests and 1,000 retrieval requests per month, then $19/month (Starter), $249/month (Pro) or a custom Enterprise contract. The open-source library costs nothing to license; you pay only for the LLM, embeddings and vector database it runs on. Everything below is taken from mem0.ai/pricing and docs.mem0.ai as of October 2026 and will change; treat it as a map, not a quote.

Mem0 pricing at a glance

According to Mem0's pricing page, the Platform tiers are:

Three things stand out. Hobby and Starter differ only in volume. The Starter-to-Pro jump is 13x in price and 10x in quota, and Pro is where production features (multi-project, analytics, Dream, private Slack) appear. And the retrieval quota is one tenth of the add quota on every self-serve tier.

The page also notes that Mem0 "supports usage-based pricing for teams whose traffic doesn't map cleanly to a fixed tier," but those rates are not published.

What does Mem0 actually meter?

Mem0 bills on two API-level counters: add requests and retrieval requests. It does not bill on stored memories, storage size, end users or tokens. The pricing page's FAQ defines the two units; the explanation below follows the API behavior in the Platform quickstart.

Add requests vs memories

An add request is one call to add. Mem0 runs an LLM extraction pass over the messages and stores zero or more memories. In the quickstart example, one add with "I'm a vegetarian and allergic to nuts" produces two memories ("Is a vegetarian" and "Allergic to nuts"). An add containing nothing memorable produces zero memories and still counts as a request. So you optimize how often you call add, not how many facts you store: one add per conversation costs one request; one per message costs one per message.

Retrieval requests

A retrieval request is a call to search (check Mem0's FAQ for whether other read paths such as get_all count on your plan). One retrieval returns many memories for one request.

Worked example

Suppose a support assistant has 1,000 monthly active users, each with one 10-turn conversation a month. You call add once per turn and search once per turn to fetch context.

• Add requests: 1,000 users x 10 turns = 10,000 per month
• Retrieval requests: 1,000 users x 10 turns = 10,000 per month

The adds fit Hobby. The retrievals exceed Hobby (1,000) and Starter (5,000), so you land on Pro at $249/month, not because you store much but because you read on every turn. Batch add once per conversation (1,000 adds) and cache retrieved context for the session (1,000 retrievals), and the same product fits Hobby for free. The retrieval quota is usually the binding constraint.

Mem0 open source vs Mem0 Platform: what is free?

The mem0ai/mem0 repository is Apache 2.0, so the library is free to use, modify and run commercially, with no request limits. It runs as a Python or Node library (pip install mem0ai / npm install mem0ai) or as a self-hosted Docker stack with a REST server and dashboard, per the open-source overview.

"Free" means free to license. Every add still runs an LLM extraction call and an embedding call; every search runs an embedding call plus a vector query. According to the same docs, the defaults are OpenAI gpt-5-mini, text-embedding-3-small, local Qdrant (library) or Postgres with pgvector (server), and SQLite for history. All are swappable, including local models through Ollama, which Mem0 suggests for "cost optimization: local LLMs, self-hosted vector DBs, no usage-based billing."

A self-hosted cost model looks like this:

monthly cost ≈ (adds × extraction tokens × LLM price)
             + (adds + searches) × embedding tokens × embedding price
             + vector store hosting
             + the engineer time to run it

According to Mem0's Platform vs Open Source page, the core loop (add, search, get, get_all, update, delete, history) is identical on both. What self-hosting gives up, as of October 2026, is the Platform-only set: the dashboard, app_id and multi-project scoping, webhooks, memory export, batch operations, custom categories, and the v3 ranking features (graph memory, memory decay, temporal reasoning and Dream). The same page says support channels are currently identical for both.

A practical rule: if you already run an LLM gateway and Postgres with pgvector, self-hosting adds little. If not, $19 Starter is cheaper than the hours to stand it up, as long as you stay under the retrieval quota.

Is graph memory included in Mem0's price?

This is the most common point of confusion in Mem0 pricing, because the vendor's materials describe it from two angles. The pricing page lists "Graph memory (entity linking)" under Pro and Enterprise. The Graph Memory docs split it in two:

Read together: shared entities boost related results at search time on every Platform tier; Pro buys the dashboard view of that graph. Per the same docs, the graph is co-occurrence based, "does not assign typed, labeled relationships between entities," and is a ranking signal only; the former relations field is always empty in the current API. If you need typed edges, ontologies or temporal validity on facts, no Mem0 tier provides that.

On the open-source side, the Platform vs Open Source page states that the earlier external graph store integration (Neo4j, Memgraph, Kuzu, Apache AGE) "was dropped when the v3 pipeline landed." OSS still extracts entities for ranking, but there is no queryable graph. Verify this against the version you run if you self-host for graph memory.

Mem0 enterprise pricing

Enterprise is custom-priced. According to the pricing page, it includes unlimited add and retrieval requests, unlimited projects, private Slack support with an SLA, on-prem deployment, audit logs, SSO and custom integrations, plus everything in Pro. Mem0's site lists SOC 2 Type I, HIPAA-ready and GDPR-ready status.

No Enterprise rates are published. The conversation starts when you exceed 500,000 adds or 50,000 retrievals a month, need an on-prem install, or need contractual support terms. The usage-based option sits between Pro and Enterprise for spiky traffic.

How Mem0 pricing compares to Zep, Letta and Cognee

Each vendor meters a different unit, so the honest comparison is on shape first and numbers second. Figures are per vendor pricing page, October 2026: mem0.ai/pricing, getzep.com/pricing, letta.com/pricing and cognee.ai/pricing.

Worked estimate

This is an estimate, not a quote. Same assistant as above with the naive pattern: 1,000 users, 10 turns each, add and search per turn, average message about 700 bytes (roughly 175 tokens).

• Mem0 Platform: 10,000 adds fit Hobby, but 10,000 retrievals push you to Pro. Estimate: $249/month.
• Zep Cloud: 10,000 Episodes at 700 bytes = 2 credits each = 20,000 credits, above the free 10,000, so Flex at $125/month. Retrieval is unmetered.
• Letta: not directly comparable; cost tracks the model tokens your agents consume plus server-side tool time, not memory operations.
• Cognee: 10,000 messages x ~175 tokens ≈ 1.75M tokens ingested. The first 1M is free; the rest at $1.00 per 1M tokens is under $1 on Standard. Order-of-magnitude only: "tokens processed" covers what the pipeline handles, which can exceed raw input tokens.

Assumptions that move these numbers: batching add per conversation drops Mem0 to Hobby; longer messages raise Zep's credits linearly; heavier enrichment raises Cognee's token count. For a wider survey see cheapest AI memory platforms by pricing; for a feature comparison see Mem0 vs Zep.

How to estimate your Mem0 bill

Four inputs determine where you land:

1. Add call frequency. Per message, per turn or per conversation. Count calls, not facts extracted.
2. Retrieval call frequency. Per turn is the common pattern and the expensive one. Count every search used to build a prompt.
3. Projects. Hobby and Starter allow one. Separate staging and production projects require Pro.
4. Feature needs. Dream, advanced analytics, the graph view and private Slack are Pro and above; on-prem, SSO and audit logs are Enterprise.

Then apply the quotas:

tier = Hobby   if adds ≤ 10,000   and retrievals ≤ 1,000   and projects = 1
tier = Starter if adds ≤ 50,000   and retrievals ≤ 5,000   and projects = 1
tier = Pro     if adds ≤ 500,000  and retrievals ≤ 50,000
else           Enterprise or usage-based

Two levers reduce the bill without changing tiers: batch add at conversation or session boundaries (extraction handles multi-message input and deduplicates), and cache retrieved memories for the life of a session instead of re-searching every turn.

For self-hosting, replace the tier table with your provider's token prices. The extraction call dominates: each add sends your messages plus Mem0's extraction prompt to the LLM, and update/dedupe decisions can add a second call. Measure a day of real traffic before extrapolating.

When Mem0's pricing model fits and when it does not

Request-based pricing fits well when:

• Writes are frequent and reads are sparse, such as a personalization layer that learns from every session but is queried once at session start.
• You want a predictable monthly number and traffic that sits inside one tier.
• Your memory unit is the extracted fact about a user, with no need for typed relationships or fact history.

It fits less well when:

• You retrieve on every turn at scale. The 10:1 add-to-retrieval ratio means read-heavy agents pay for Pro long before exhausting the add quota.
• You run many small agents that each need their own project; Hobby and Starter are single-project.
• You need the graph beyond ranking: typed edges, an ontology, or "what was true last month." No Mem0 tier returns relations.
• Your cost driver is text volume rather than call count. Request billing ignores payload size, which helps if messages are long and hurts if they are many and short.

If several apply, the Mem0 alternatives roundup covers options with different metering, with Zep alternatives and Letta alternatives for the other two vendors above.

How Cognee prices memory differently

Cognee meters tokens processed rather than API requests. The Free tier includes 1M tokens and one workspace with unlimited users and API calls; Standard is $1.00 per 1M tokens processed plus $5 per month per additional workspace; Enterprise is a bring-your-own-cloud engagement with custom terms. The engine is open source under Apache 2.0 at github.com/topoteretes/cognee, and self-hosting is free, with Postgres-only, Neo4j, Kuzu, FalkorDB, LanceDB and pgvector backends.

The practical difference from Mem0 is that read frequency does not affect the bill: an agent that calls recall every turn pays the same as one that calls it once a session. Cost scales with how much text you remember. The knowledge graph (typed entities, relationships, provenance) is built on every plan; bi-temporal memory with validity windows is Enterprise. For teams moving from Mem0 there is a Mem0Source import adapter, and the same memory is exposed to Claude Code, Cursor and Codex through an MCP server.

FAQ

Is Mem0 free?+

Yes, in two ways. The Mem0 Platform Hobby tier is free and, as of October 2026, includes 10,000 add requests and 1,000 retrieval requests per month, unlimited end users and one project. The open-source library is Apache 2.0 and free to self-host without request limits, but you pay your own LLM, embedding and vector database costs.

How much does Mem0 cost per month?+

According to mem0.ai/pricing in October 2026: Hobby is $0, Starter is $19/month (50,000 adds, 5,000 retrievals), Pro is $249/month (500,000 adds, 50,000 retrievals, unlimited projects, analytics, Dream, graph view), and Enterprise is custom with unlimited requests, on-prem deployment, SSO, audit logs and an SLA. Usage-based pricing is available on request.

What counts as a memory in Mem0 pricing?+

Mem0 does not bill on memories; it bills on add and retrieval requests. One add call is one add request regardless of how many memories extraction produces (the quickstart example yields two from one call). One search call is one retrieval request regardless of how many memories it returns. Stored memories, storage size and end users are not metered on the published tiers.

Does the Mem0 free tier include graph memory?+

Partly. According to Mem0's Graph Memory docs, entity extraction, linking and the retrieval ranking boost are automatic on all Platform plans, including Hobby. The interactive graph view in the dashboard is limited to Pro and Enterprise, which is why the pricing page lists graph memory there. The graph is co-occurrence based and exposes no typed relationships at any tier.

Can I self-host Mem0 for free?+

Yes. The mem0ai/mem0 repository is Apache 2.0 and ships as a Python and Node library plus a Docker-based server with a dashboard, with no license fee or request quota. Your costs are the extraction LLM (default OpenAI gpt-5-mini), embeddings (default text-embedding-3-small), a vector store (local Qdrant or Postgres with pgvector) and operations time. Platform-only features such as Dream, webhooks, memory export and the native graph are not included.

Is Mem0 cheaper than Zep?+

It depends on the read/write ratio. Mem0's paid tiers start at $19/month versus Zep Flex at $125/month, so at low volume Mem0 is cheaper. Zep meters only ingested Episodes (1 credit per 350 bytes) and not retrieval, storage or users, so a read-heavy agent that needs Mem0 Pro ($249) can fit Zep Flex ($125). Model both against your own call counts and message sizes.