What are the cheapest and most scalable persistent memory APIs for AI applications?
TL;DR
- There is no single cheapest memory API: Mem0, Zep, Supermemory, Cognee and Hindsight bill by five different meters, so only the cost of one stated workload can be compared, and this page computes it at two workloads.
- Where it stops: Zep rejects an episode over 10,000 characters, Supermemory takes up to 1 MB of text per write, Zep's paid plans allow 600 and 1,000 requests a minute, and Supermemory's API keys allow 500 by default.
- Past the limit: Zep bills overage at a stated rate, Supermemory allows top-ups only on paid plans, and Mem0 publishes no overage rate: its FAQ says the rate is shown when you turn usage-based billing on.
- Self-hosting: all five document a way to run without the vendor's usage bill (for Zep, through Graphiti), but the model, the storage and the servers are then yours to pay.
Published by Mnemoverse, a persistent-memory API for AI agents.
Reading "cheapest" as the monthly bill at a stated workload, and "most scalable" as the limits each vendor documents, is this page's framing; every price and limit is quoted from the vendor's own pages on the date in Sources, and the arithmetic is this page's.
Plan details as read on 16 November 2026, monthly list prices:
| System | What is counted | What is not counted | Free | Paid steps |
|---|---|---|---|---|
| Mem0 | Adds and retrievals a month | End users ("Unlimited end users") | First 30 days: 10,000 adds and 1,000 retrievals a month, model calls paid by Mem0. Then, with your own LLM key: 50,000 adds and 10,000 retrievals a month at no charge from Mem0 | On mem0.ai: Free and Custom, by contract. Through the Vercel Marketplace, Mem0's docs (24 August 2026) list Starter at $20 a month with 5,000 retrieval calls a month and 50,000 memories |
| Zep | Credits for the size of each episode | Retrieval, storage, threads, users and graph storage use 0 credits | 10,000 credits a month, no rollover or auto top-up; variable rate limits and lower-priority episode processing, and a 5 RPM penalty past its quota (rate limits) | Flex $125 a month with 50,000 credits, then $25 per 10,000 credits. Flex Plus $375 a month with 200,000 credits, then $75 per 40,000 |
| Supermemory | SM tokens ingested, searches and other operations, drawn from a monthly credit balance | For supported updates with the same customId, unchanged content is not billed again on the token meter | $5 of credits a month | Pro $19 with $20 of credits, Max $100 with $130, Scale $399 with $600. Paid plans can buy top-up credits |
| Cognee | Tokens processed; search and recall also spend credits | Storage is not billed but is capped | Pricing page: 1 workspace and 1M tokens. Billing docs: 10M tokens | $1.00 per 1M tokens processed; $5 a month for each additional workspace |
| Hindsight | Retained input tokens, recalled output tokens, Reflect calls, and storage after 30 days | Failed operations; background processing is included | New accounts start with $5 of free credit | Pay as you go, with no fixed monthly fee and no per-seat pricing |
There is no single cheapest memory API, only a cheapest one at your workload
A plan's starting price does not tell you how many writes and reads it covers. Zep counts the bytes of each episode, Supermemory spends a dollar balance on tokens and searches, Cognee meters processed tokens, Hindsight prices what you store and what it returns, and Mem0 counts calls and, on your own key, leaves the model bill with your provider. The State of AI Agent Memory 2026 report lists the plans of 17 systems, and a comparison of six memory APIs covers, among other things, what each costs to start; this page does neither. Its reading is that a price list cannot rank them; a workload can.
What each memory API bills for
A billing unit is what a vendor counts and invoices. A per-request limit is the largest amount one write call accepts. The same word does different work across vendors: "credits" are blocks of episode bytes at Zep, a dollar balance at Supermemory, and prepaid dollars at Cognee and Hindsight, while Supermemory's "query" is a search.
- Mem0 counts adds and retrievals a month. "Adding a memory runs language model calls that extract and organize it. With your key, those calls bill to your provider account" (pricing FAQ).
- Zep: "Each Episode you send uses credits based on its size": one credit for up to 350 bytes, and one more for each additional 350 bytes or part of them. "A 640-byte Episode uses 2 credits; a 1,200-byte Episode uses 4 credits" (pricing).
- Supermemory charges plain-text memory at $5 per 1M SM tokens (rich content at $10 per 1M on any plan; its billing page counts PDFs and media as rich), searches at $5 per 1M queries, and other operations at $100 per 1M. The tokenizer behind SM tokens is not named on the pages read (pricing).
- Cognee charges $1.00 per 1M tokens processed, and "every operation that spends credits", including "search or recall", "is checked against your workspace balance before it runs". How many tokens a search spends is not stated on the pages read (billing).
- Hindsight charges Retain at $10.00 per million input tokens, Recall at $0.75 per million tokens it returns, Reflect at $0.05 per call, and storage at $0.25 per million tokens a month for memories older than 30 days. "Tokens are counted with the o200k_base tokenizer", and "Recall is charged on the results it returns: each result's text plus its context" (billing).
What the same workload costs on each
Two workloads, each write a 700-byte note and each read returning ten results:
- N1: 10,000 writes and 1,000 reads a month (the size of Mem0's first-30-days allowance).
- N2: 50,000 writes and 10,000 reads a month (the size of Mem0's own-key allowance).
The figures below are monthly, at list prices, before any starting credit. The assumptions are in How the numbers were computed.
| System | N1 | N2 |
|---|---|---|
| Mem0 | First 30 days: $0, model calls included. After that, with your own key: no charge from Mem0; Mem0 estimates the model calls at "about $3.55 to $5.34 per 1,000 adds", about $35.50 to $53.40 at your provider | Above the first-30-days allowance. With your own key, exactly at the 50,000 adds and 10,000 retrievals allowance: no charge from Mem0; by the same estimate about $177.50 to $267.00 at your provider |
| Zep | 20,000 credits, above Free's 10,000. Flex: $125 | 100,000 credits. Flex: $125 + 5 × $25 = $250. Flex Plus: $375 |
| Supermemory | $6.86 of usage, above Free's $5 (its migration guide says top-ups are paid-plan only). Pro: $19, which includes $20 of credits | $34.30 of usage, above Pro's $20. Max: $100, which includes $130. Or Pro at $19 plus $14.30 of top-up credits beyond its balance |
| Cognee | $1.37 of tokens, plus search. Inside the 10M free tokens of the billing docs, above the 1M of the pricing page; neither page says the free tokens renew each month | $6.85 of tokens, plus search. Same two readings of the free allowance, which neither page says renews monthly |
| Hindsight | At least $14.73 in the first month: $13.70 Retain plus at least $1.03 Recall. Storage then adds about $0.34 a month for each month of stored writes, about $3.77 a month by month 12 | At least $78.78 in the first month: $68.50 Retain plus at least $10.28 Recall. Storage then adds about $1.71 a month for each month of stored writes, about $18.84 a month by month 12 |
Prices as read on 16 November 2026; plans change, recompute with the formula below.
What the numbers say. On the parts this page can price, N1 runs from $1.37 plus search (Cognee) through at least $14.73 (Hindsight, before its $5 of starting credit) and $19 (Supermemory Pro) to $125 (Zep Flex). At N2 the priced parts run from $6.85 plus search (Cognee) through $33.30 (Supermemory Pro with top-ups), at least $78.78 (Hindsight) and $100 (Supermemory Max) to $250 (Zep Flex). That order is this page's arithmetic at these two workloads, nothing more: a different write size or read mix can reorder it. Zep, for one, bills in steps of 350 bytes, so a 701-byte note costs 3 credits instead of 2.
Mem0 is not on the same footing. With your own key, the language-model calls that extract memories bill to your LLM provider, while the other four price their processing into their own units. A Mem0 $0 and a Zep $125 are not the same kind of number. Organizations created through the Vercel Marketplace "can't use BYOK" (bring your own key; Vercel integration), so the own-key allowance does not apply there.
Floors and averages, not totals. Cognee's figures exclude search, whose token use is not stated, and assume that tokens processed equal the note's own tokens. Hindsight's figures assume no context: its billing page charges Retain and storage on each item's content and context, and Recall on "each result's text plus its context", so context raises all three, and the 137 tokens per returned result is this page's assumption. Supermemory's top-up route assumes buying exactly the $14.30 shortfall, so it is a monthly average: the console offers top-up presets such as $10 and $25, a given month's outlay can be higher, and bought credits carry forward because they do not expire.
Where each one stops scaling: the published limits
These are the limits on the vendor pages read, not a stress test: throughput, latency and recall quality were not measured.
| System | Size of one request | Request rate | Storage and other limits |
|---|---|---|---|
| Mem0 | Not stated on the pages read | "Managed quotas per workspace"; the pages read give no per-plan request rate | Monthly add and retrieval allowances (above) |
| Zep | 10,000 characters per episode; longer episodes are rejected, not truncated. Thread messages: 4,096 characters each by default, 30 messages per call | Flex 600 and Flex Plus 1,000 requests a minute; Enterprise "committed, guaranteed rate limits". Free has variable limits, Free and Flex limits "may" be lowered depending on service usage, and "A Free account that exceeds its usage quota enters a 5 RPM penalty mode" (pricing, rate limits) | "Zep does not configure a fixed graph-size limit. Payload, request-rate, and processing-concurrency limits still apply." (FAQ). Since 9 November 2026, Flex Plus processes ingestion at 1.5 times the default rate (changelog) |
| Supermemory | Text 1 MB, files 50 MB, fetched URL content up to 10 MB | 500 requests a minute per API key by default (billing); a scoped key can be created with a limit of up to 10,000, in tiers of 500, 1,000, 2,000, 5,000 or 10,000 (authentication) | Organization seats: 1 on Free, 3 on Pro and Max, unlimited on Scale and Enterprise (billing) |
| Cognee | Not stated on the pages read | "Usage-based": requests draw on the workspace's prepaid token credits; a 429 means a rate limit, with no number given (API reference) | 1 GB of stored data and 50,000 documents per member, per workspace, checked on add and add_text: a call that would cross either limit is rejected with 413 and none of its files are stored (remember is not checked against them at request time). A Cloud workspace "is put to sleep once it has been idle for 3 days" (workspace lifecycle) |
| Hindsight | Not stated on the pages read | Not covered on this page (note below) | The Cloud pricing page lists "Automatic scaling"; Enterprise adds "Hindsight Memlake for large memory volumes" |
RPM means requests per minute. This page does not cover a request-rate limit for Hindsight Cloud. A 700-byte note is far inside Zep's and Supermemory's size limits; a longer document has to be split before Zep will take it. Zep's episode limit is counted in characters while its credits are counted in bytes, and the two part ways for text outside plain ASCII.
What happens past the plan limit
- Mem0: "Calls past the limit return an error until your limits reset next month." With your own key, you can turn on usage-based billing and set a monthly spending cap; "The rate is shown when you turn it on" (pricing FAQ).
- Zep: on Free, once the credits are used up, "episodes will stop processing until the next billing cycle or until you upgrade to a paid plan". Flex adds 10,000 credits for $25 and Flex Plus 40,000 for $75, with auto top-up at 20% and a credit rollover of 30 days on Flex and 60 on Flex Plus (pricing, FAQ).
- Supermemory: "Free orgs upgrade to a paid plan once they run out (top-ups are paid-plan only)". Plan credits reset each billing period with no rollover; top-up credits "never expire". Auto top-up limits "control automatic credit purchases; they are not a cap on your total invoice" (pricing, billing, migration guide).
- Cognee: "When the balance is too low, the request is rejected with HTTP 402". Auto recharge has a monthly limit: "you set it yourself, and auto recharge never charges more than that in a month" (billing).
- Hindsight: you buy a credit package of $10, $25, $50 or $100, or a custom amount, at "1 credit = $1 USD". The daily spend cap is "The most auto-recharge can charge in one UTC day". "You're only charged for operations that succeed" (billing).
Running it yourself: no vendor bill, but not free
- Cognee: "Cognee is open source. Run the full memory engine locally or on your own stack", which it calls "free, forever"; "Self-hosting the open-source engine lets you bring your own model" (pricing, FAQ).
- Zep: "Zep Community Edition, which allows you to host Zep locally, is deprecated and no longer supported." Its self-hosting alternatives are Graphiti, "The open-source Context Graph framework that powers Zep Cloud", and BYOC deployments "where Zep runs in your own cloud infrastructure" for enterprise customers (FAQ). Graphiti itself is compared on Hindsight vs Graphiti.
- Hindsight: "Hindsight is MIT licensed with no usage limits, no telemetry, and no restrictions" (pricing).
- Mem0: the open-source version lists "local LLMs (Ollama), self-hosted vector DBs, no usage-based billing" (platform vs open source).
- Supermemory: "supermemory local is a free self-hosted binary for up to 10,000 stored documents; it runs on your machine and is not open source." Asked whether it is open source, its pricing page answers "Partly": the SDKs and MCP server are, "The memory engine is not open source". Running it in your own cloud or on a dedicated instance is available on Scale and Enterprise (pricing).
This page's reading: self-hosting removes the vendor's bill, not the cost. The model, the storage and the servers are yours to pay, and so is the work of running them, from backups to upgrades.
Starting credits and startup programs
- Hindsight: its pricing page and its 3 November post say new accounts start with $5 of free credit. Its startup program offers "Up to $15,000 in Hindsight Cloud credits", starting with $1,000 and adding more in steps, to incorporated companies with under $10M in funding (angel-backed, pre-seed, seed or early Series A) that build a product on Hindsight and are not already paying customers; credits last "3 months from approval".
- Zep: Free includes 10,000 credits a month. Zep for Emerging Companies is a discounted annual price: "$13,000 for your first year, with more than $40,000 in total discounts over the three-year term", a 12-month commitment prepaid annually, for companies that have raised between $1M and $10M.
- Supermemory: Free includes $5 of credits each month. "Qualifying early-stage startups and academic research teams get the Scale plan free for three months, including its included usage, plus dedicated support" (pricing).
- Cognee: the pricing page includes 1M tokens and the billing docs say 10M. Its startup pricing, a discounted 12-month package of its Enterprise engagement in your own cloud, applies to companies before Series B, with no price published.
- Mem0: the first 30 days come with model calls paid by Mem0 (pricing FAQ).
How the numbers were computed
Notation: W writes a month, R reads a month, B bytes per write, T tokens per write, K results per read.
- B = 700 bytes, the episode size in Zep's pricing calculator.
- T = 137 tokens, an assumption from a measurement: this page counted three English memory notes of about 700 bytes (702 to 704), written for this measurement, with o200k_base, the tokenizer Hindsight names, and got 132, 139 and 141 tokens. Supermemory's and Cognee's tokenizers are not named on the pages read, so the same T is an assumption for them too.
- K = 10 results per read, each as long as a write.
- Monthly list prices, monthly billing, no annual or Enterprise pricing; for Hindsight, no Reflect calls and none of its model operations (Retrieve Model, Refresh Model); its billing page says Refresh Model charges "can grow with how much you write" once knowledge base pages exist.
The rules, each from the vendor's own page:
- Zep: credits = W × ceil(B / 350), reads 0 credits; then the plan and its overage.
- Supermemory: usage = W × T × $5 per 1M SM tokens + R × $5 per 1M searches; then the smallest plan whose included credits cover it, or a paid plan plus top-up credits.
- Cognee: usage = W × T × $1.00 per 1M tokens processed, plus search at a token use the pages read do not state.
- Hindsight: W × T × $10.00 per 1M (Retain) + R × K × T × $0.75 per 1M (Recall, a floor) + tokens older than 30 days × $0.25 per 1M a month (storage).
- Mem0: W and R against the add and retrieval allowances; for the own-key model bill, W ÷ 1,000 × Mem0's own "about $3.55 to $5.34".
Two self-checks reproduce the vendors' own examples:
- Zep's calculator: 15,000 episodes × 2 credits + 20,000 webhooks × ⅛ credit = 32,500 credits, inside Flex at $125, the figure the calculator shows.
- Supermemory's example of 1,000 users who each add 20,000 tokens and run 200 searches: 20,000,000 tokens × $5 per 1M + 200,000 searches × $5 per 1M = $101, matching its "about $101 at list rates, inside the $130 of credits the Max plan includes".
Converting one vendor's unit into a fixed workload is not new: a 19 October 2026 post by statewave ran Zep's per-350-byte rule against a fixed workload. Its author builds a competing product and says so; no figures were taken from it.
What this page does not claim
No vendor was tested and no bill was run. Prices, limits and plans are the vendors' own pages on the date in Sources and change often; recompute with the formula. Where a rate is shown only inside the product or on request, the table says so instead of guessing. The workloads, the byte-to-token ratio and the results per read are this page's assumptions, stated in "How the numbers were computed". Where a vendor's pages say nothing about a limit, the table says so with the pages read; that is not a claim the product lacks one. Self-hosting figures exclude the model, storage and servers you pay for yourself.
Common questions
What are the cheapest and most scalable persistent memory APIs for AI applications?
No single API is cheapest or most scalable for every workload, because Mem0, Zep, Supermemory, Cognee and Hindsight each bill a different unit. Price your own writes and reads on each vendor's page with the vendor's own rule, then check the size of one write, the request rate, the storage caps, and whether the model calls that process memory are inside the quoted bill.
How do you compare memory API prices when each vendor bills a different unit?
Pick one workload (writes a month, average size, reads a month, results per read), convert it into each vendor's unit with the vendor's own rule, and price it on the vendor's own page. Zep charges a credit per 350 bytes of an episode, Hindsight charges retained input tokens and recalled output tokens, and Supermemory charges SM tokens and searches from a monthly credit balance.
Where does each memory API stop scaling?
By the published limits: Zep rejects an episode over 10,000 characters and allows 600 and 1,000 requests a minute on its paid plans; Supermemory takes up to 1 MB of text per write and 500 requests a minute per API key by default (a scoped key can be set up to 10,000); Cognee caps each member at 1 GB and 50,000 documents per workspace; Mem0 describes managed quotas per workspace; Hindsight's pricing page lists "Automatic scaling" for its Cloud. These are documented limits, not measured capacity.
Is self-hosting a memory engine free?
By this page's reading, there is no vendor bill, but it is not free. Cognee calls its open-source engine "free to self-host, forever" and says self-hosting lets you bring your own model; Zep points to Graphiti, the open-source framework that powers Zep Cloud, since its Community Edition is deprecated. You still pay for the model, the storage, the servers and the work of running them.
What does a memory API charge for: writes, reads or storage?
It depends on the vendor. Zep bills ingestion and not retrieval or storage, Mem0 counts adds and retrievals, Hindsight bills writes, reads and storage separately, and Cognee's search also spends credits.
Sources
All read 16 November 2026.
- Mem0: pricing; pricing FAQ; Vercel integration (dated 24 August 2026); add memory; platform vs open source.
- Zep: pricing and calculator; rate limits; FAQ and FAQ, credits; prepare data for ingestion; changelog, 9 November 2026; Zep for Emerging Companies.
- Supermemory: pricing and its Markdown version; billing and usage; authentication; content types; add memories; migration from Mem0.
- Cognee: pricing; FAQ; account and billing; data ingestion; workspace lifecycle; API reference.
- Hindsight (Vectorize): pricing; Introducing Hindsight Models; billing; startup program.
- Analysis by a competing vendor: statewave on Zep's per-350-byte credits, 19 October 2026.
Related
- State of AI Agent Memory 2026: the plans of 17 systems, re-read in November 2026.
- Best persistent memory APIs compared: six systems on six questions, including what it costs to start.
- Cross-IDE context platforms for teams
- MCP servers for agent memory, compared
- Python SDKs for agent memory compared
- Persistent memory for Claude Code
Sources were read on 16 November 2026; the page describes them as of that date.
Edward Izgorodin · Mnemoverse · 16 November 2026
