Mem0 Pricing: Plans, Limits and What You Pay (2026)
Nov 10, 202614 min read
Mem0 is a memory layer for AI agents, offered as a hosted platform and as an open-source library, and it slots into agent workflows built on tools like Activepieces just as readily as into hand-coded stacks.
The hosted bill follows two things: how many memories you store and how often you retrieve them.
Understand Mem0's metered pricing units
Hosted platform versus open-source library
If you want storage, extraction and search run for you, the hosted platform does it and bills by usage. The open-source library gives you the same pattern to run on your own infrastructure.
Because the project has real adoption, self-hosting is a credible option. According to Upd, the GitHub repository passed 25,000 stars, then 41,000, and now stands at 68,686.
Mem0 stored memories and retrievals explained
Mem0's pricing page and docs define four units. Two of them are the ones your workload will actually hit:
- Stored memories: the distilled facts Mem0 keeps per user or agent, triggered when Mem0 processes an add request.
- Add requests: calls that write new conversation content to memory, triggered every time your agent saves something.
- Retrieval requests: search calls that pull relevant memories back, triggered on every agent turn that needs context.
- Plan limits: the per-tier caps on stored memories and retrieval requests, triggered when usage crosses them.
Because it fires on every turn, retrieval is the unit that scales with traffic. Mem0's (source) shows each query costing about 6,956 tokens on LoCoMo, 6,787 on LongMemEval and 6,719 on BEAM (1M).
Prompt size stays near 7,000 tokens even as the memory store grows, so your model spend stays flat per query. The request count is what moves your plan.
Every workflow step that adds or searches counts as a request, so the connector you reach Mem0 through is part of the plan.
Activepieces lets you generate a missing integration with AI and add it privately to your own instance, with no vendor release to wait on, and roughly 60% of the 747 integrations counted from its open-source monorepo were built by the community.
If you are running this arithmetic for your own team, see what the same workload costs on Activepieces.
View all Mem0 plans and pricing limits
Every time a workflow step writes or reads memory, it spends one of Mem0's two metered units, adds or retrievals. The limits on the pricing page are the ones to read first.
Mem0 free plan limits and allowances
I read the page on 2026-11-10. The free plan has two limit regimes, depending on whose model calls pay for extraction.
For the first 30 days with model calls on Mem0, it costs $0 and allows 10,000 adds and 1,000 retrievals a month; with your own LLM key it costs $0 and allows 50,000 adds and 10,000 retrievals a month.
Bring your own LLM key and the add ceiling rises fivefold while the retrieval ceiling rises tenfold. That means you carry the model cost in exchange for headroom.
Mem0 Starter, Pro and Enterprise plan pricing
Starter is the first paid step at $19 a month. It is the plan a team lands on when the free allowance runs out but the workload is still one product with modest traffic.
I did not record its memory or retrieval caps, so read both numbers off the pricing page before you rely on it.
Pro costs $249 a month, roughly thirteen times Starter, and adds graph memory. That jump is worth paying only when your retrieval count or your need for graph memory clearly passes what Starter covers.
As with Starter, I have no verified caps to quote, so check them against your own monthly request count.
Enterprise has no listed price; it is a quote. Expect it to matter when you exceed Pro's limits or need terms a self-serve plan doesn't offer, such as data residency. Treat any number you hear before that conversation as a guess.
Which Mem0 limit decides your plan
On both regimes, retrievals run out first.
Under the trial allowance, adds outnumber retrievals ten to one, but an agent that recalls memory on every turn reverses that ratio fast.
C17 reports that at 1,000 retrievals a month, a workflow that fires 50 recalls a day stops about three weeks in, and anything after that fails or forces an upgrade.
With your own key, the 10,000-retrieval ceiling is roughly 330 recalls a day. That's comfortable for a single-agent prototype and thin for a team's shared assistant.
What does Mem0 cost realistic teams?
For a support agent, the retrieval count usually forces the plan before the memory count does, and the bill is whichever of the two meters crosses a plan limit first.
Mem0 cost assumptions for a support agent
Take a five-person team's support agent as the workload. It recalls stored customer context at the start of every conversation and again whenever a customer changes topic.
Each customer accumulates memories slowly, but every conversation triggers several retrievals. That asymmetry is why retrievals, not storage, tend to hit a limit first. I haven't pinned this to specific volumes, so check each row against the current plan limits before you trust it.
To see how each stage's two meters are derived and which plan rule applies to them, read the table. Go across to the last two columns: they decide the bill, and the earlier columns only feed them.
| Stage | Active users | Memories per user | Retrievals per conversation | Total memories | Monthly retrievals | Plan landed on | Monthly bill |
|---|---|---|---|---|---|---|---|
| Prototype | The team and a few test customers | Few, mostly seeded by hand | Low, since you're debugging | Users × memories per user | Conversations × retrievals each | The free tier, if both meters fit | No charge |
| Launch | Real customers, one product | Growing with each ticket | Several, with topic switches | Users × memories per user | Conversations × retrievals each | Starter, if both meters clear its limits | $19 a month |
| Scaled | The full customer base | Mature histories | Several, plus automated follow-ups | Users × memories per user | Conversations × retrievals each | Pro, or Enterprise terms past its limits | $249 a month, or a quote |
Prices and plan limits checked against mem0.ai on November 10, 2026.
You jump a tier when either meter passes a limit, not when both do. Retrieval volume alone can push a team with modest storage up a tier, and the reverse holds for long-lived customer histories.
Hidden costs and limits teams hit on Mem0
Beyond retry logic, which is only the first way the metered unit surprises you, five other costs sit outside the plan price, and most appear only after a workload has run for a while.
The list below is what to audit before committing to a tier:
- Overage charges or a forced upgrade when you pass a plan's cap
- Free tier limits that end a prototype sooner than expected
- LLM and embedding spend when you self-host the open-source version
- Rate limits and features reserved for higher plans
- Cleanup of duplicate and stale memories
If you haven't measured your retrieval volume, annual billing is a risk, since it commits you to a tier before you know your usage.
Costs outside the invoice
Run it yourself and the subscription disappears, but the work moves onto your own accounts: every memory extraction and every query spends LLM and embedding tokens you pay for directly.
Budget engineering time for deduplication and expiry, because duplicate and stale memories inflate your stored count and degrade retrieval quality.
Worth checking against a plan that does not meter every step: one credit covers a whole run on Activepieces.
Mem0 against Zep, Letta and self-hosting
Counting engineering hours, Mem0's hosted plans are the cheapest way to run a small team's memory layer. Zep and Letta meter differently, and self-hosting only wins once the hosted limits are certain to bind.
| Entry price | Free tier | Billing unit | What paid unlocks | Self-host option | |
|---|---|---|---|---|---|
| Mem0 hosted | $19/month (Starter) | 10,000 adds and 1,000 retrievals for 30 days; 50,000 adds and 10,000 retrievals with your own LLM key | Memories stored, retrieval requests | Higher caps; Pro at $249/month adds graph memory | See next row |
| Mem0 OSS self-hosted | $0 licence | Not applicable | Your infrastructure and LLM calls | Whatever you build and operate | Yes, Apache 2.0 |
| Zep | $125/month (Flex) | 50,000 credits/month | Credits | More credits, higher rate limits | Graphiti, its open-source graph library, not the full product |
| Letta | $20/month (Pro) | Yes, limited | Plan tier and usage | Higher agent and usage limits | Yes, open-source server |
Pick the row whose unit your workload exhausts last, not the row with the lowest first number.
When self-hosting Mem0 is cheaper
Self-hosting is cheaper on the invoice and rarely on the calendar. For 1M memories, C17's vector database comparison puts a self-run Hetzner server at $9.99 a month, Neon Launch at $21.85 and Supabase Pro at $25.
That $9.99 undercuts Mem0's $19 Starter, but it buys only storage. Backups, upgrades, retrieval tuning and on-call remain yours.
Go managed with Neon or Supabase and the gap narrows to a few dollars over Starter. At that point you're paying hosted prices while still running the memory logic yourself.
Self-hosting wins only when you exceed the Pro tier's limits or when data residency forbids a vendor.
Feeding Mem0 from business apps with Activepieces
Nothing in Mem0 collects memory for you, so something upstream has to decide what reaches its API, and Activepieces, an automation builder with an MIT-licensed core and 747 integrations in its open-source monorepo, can be that something.
Since you're billed on memories stored and retrieval requests, the filter you place in front of Mem0 is a cost control as much as a plumbing choice.
What the workflow does
In the screenshot below, a workflow is titled "HubSpot Tickets Categorization". A HubSpot trigger fires on each new ticket, two AI steps rewrite and then categorize it, and a Router splits the result into branches (with an "Otherwise" path for anything unmatched).
Three steps post messages, apparently to Slack.
Take the shape, not the content: trigger, clean-up, classify, route. Replace the Slack steps with a call to Mem0's API on the branch you want remembered, and the same layout feeds memory instead of a channel.
Operationally, the trigger is the useful part. Tickets, CRM notes or chat logs arrive as events, so you don't write polling code or maintain a connection to each source.
What Activepieces doesn't do is judge value for you; that judgment lives in the AI and Router steps, and you have to define it.
A run costs 1 credit however many steps the filter has, and an AI step on a fast model adds 2 credits.
Keeping stored memories, and the bill, small
Send every ticket through unfiltered and each one becomes a candidate memory, and a memory you store is a unit you're metered on.
A noisy source such as a support queue will fill your quota with greetings, duplicates and one-off complaints long before it yields anything durable.
To address this, put three controls in the flow:
- Rewrite each item into a short, self-contained statement before sending, so Mem0 receives a fact rather than a thread.
- Classify it, and let only categories that describe lasting preferences, account facts or decisions reach the Mem0 step.
- Send everything on the "Otherwise" branch nowhere, or to a log you can audit.
Filtering costs something too: each AI step has its own cost, billed by whichever model provider you connect. Use a small, fast model for classification so the filter costs less than the memories it prevents.
You also take on running the workflow, so check its failed runs; a silent failure means memories that never get stored.
Choosing a Mem0 plan this week
Choose the plan whose limit your workload reaches last, and work that out from your own logs before you open the pricing page.
- Count your active users over a typical month from your logs, not your signup total. Dormant accounts store nothing and retrieve nothing, so counting them overstates your needs.
- Count memories per active user. Take a sample of long-standing users and see how many memories each has accumulated. Stored memories are a metered unit, so this per-user figure multiplied by active users is your storage-side number.
- Estimate retrievals per conversation. Check how many times your agent queries memory in one session, including any automatic lookup on every turn. Multiply by conversations per month to get your retrieval requests, the second metered unit.
**Choose the plan whose limit your workload reaches last, and work that out from your own logs before you open the pricing page.
Use a busy week rather than an average one.
- Compare both numbers against each plan's limits and pick the plan where the tighter of the two is reached last. Most workloads are bound by one unit; chatty agents hit retrievals first, while long-lived assistants hit stored memories first.
- Set a usage alert below the limit, not at it. A threshold that fires at the limit tells you after the overage has begun, so leave enough headroom to act, whether that means upgrading or trimming retrieval calls.
- Put a recheck date on the calendar for self-hosting the open-source version. Revisit it when your usage has grown or the managed bill has changed, and price the comparison with the engineering hours of running it yourself, since that cost decides whether it wins.
Frequently asked questions
Before you buy
Before you commit a budget, confirm the specifics against Mem0's pricing page, because each answer below turns on the metered unit.
Does Mem0 have a free plan?
Yes, Mem0's hosted platform has a free tier.
It's capped on the same units as the paid plans, memories stored and retrieval requests, so a prototype fits comfortably but a production agent with real traffic will reach the cap first on whichever unit your workload uses most.
Changing plans
Can I switch Mem0 plans mid-month?
Plan changes are made from the account dashboard, but I haven't confirmed how Mem0 prorates a mid-cycle change, so check the billing page rather than assume.
In practice, move up before a known peak, not after it. If an upgrade isn't prorated, you may pay for a full cycle to cover a few busy days.
Self-hosting costs
Is open-source Mem0 really free to run?
The license is free, and the running costs aren't. You supply the vector store and hosting, you pay your language model provider for the calls that extract and update memories, and you take on upgrades, monitoring and incident response.
Self-hosting wins only if those engineering hours cost less than the plan you'd otherwise buy.
Retrieval charges
Does Mem0 charge for retrievals as well as storage?
Yes, the hosted plans meter retrieval requests alongside memories stored, and they're separate limits. A read-heavy agent that searches memory on every turn can exhaust its retrieval allowance while storage sits nearly empty, so size the plan by whichever limit you reach last.
Pricing changes
How often does Mem0 change its pricing?
I have no verified change history, so I won't give you a cadence. Pricing for hosted AI tooling shifts often enough that you should treat any quoted plan as a snapshot.
Re-read the pricing page at each renewal, and before you sign anything annual.
Related reading
Running the numbers
See what the same workload costs here.
Free forever plan, and every paid plan self-hosts at no extra cost.
See pricing Talk to sales
