---
title: "Mem0 vs Supermemory: Two Memory APIs Compared"
description: "Mem0 vs Supermemory compared: extracted user memories against document memory with connectors, what search returns, pricing, and self-host options."
canonical: https://past.dev/blog/mem0-vs-supermemory
date: 2026-09-03
category: Research
authors: The past.dev team
---
# Mem0 vs Supermemory: Two Memory APIs Compared

Mem0 vs Supermemory is a comparison of two hosted memory APIs with different centers of gravity. Mem0 extracts short fact strings from conversations and serves them back per user, with an Apache 2.0 library underneath ([memory operations](https://docs.mem0.ai/core-concepts/memory-operations), [repo](https://github.com/mem0ai/mem0)). Supermemory ingests documents as well as chat, its `content` field accepts text, URLs, PDFs, images, and video, and connectors pull in Google Drive, Notion, Gmail, and OneDrive ([add document](https://supermemory.ai/docs/api-reference/ingest/add-document), [connectors](https://supermemory.ai/docs/connectors/overview)). Conversational personalization points to Mem0; document-plus-conversation context in one store points to Supermemory.

## The dimensions that matter

| Dimension | Mem0 | Supermemory | past.dev |
|---|---|---|---|
| Memory model | LLM-extracted fact strings, stored additively, plus a built-in entity graph ([docs](https://docs.mem0.ai/core-concepts/memory-operations)) | Documents processed into memories and chunks; one `content` field takes text, URLs, PDFs, images, video ([docs](https://supermemory.ai/docs/api-reference/ingest/add-document)) | Raw text ingested with its original timestamp; derived facts keep links to sources |
| Temporal handling | `timestamp` on add backdates `created_at`; optional `expiration_date` ([API](https://docs.mem0.ai/api-reference/memory/add-memories)) | `documentDate` marks when content is from, distinct from upload time; results carry `updatedAt` and version history ([API](https://supermemory.ai/docs/api-reference/ingest/add-document)) | Event time from the source timestamp, validity windows, supersession links |
| Entity and identity | Schema-free entity web inferred from co-occurrence ([docs](https://docs.mem0.ai/open-source/features/graph-memory)); scoping via `user_id`, `agent_id`, `run_id` | `containerTag` partitions memories per user or project ([docs](https://supermemory.ai/docs/concepts/container-tags)); user profiles assembled from memories ([docs](https://supermemory.ai/docs/memory-router/overview)) | Entity resolution at ingestion links references across email, transcripts, tickets, chat |
| A response contains | Memory strings with `score`, `created_at`, `updated_at`, `categories` ([API](https://docs.mem0.ai/api-reference/memory/v2-search-memories)) | `memory` or `chunk` entries with `similarity`, `updatedAt`, a `context` object holding version history and related memories, an `isAggregated` flag ([API](https://supermemory.ai/docs/api-reference/recall-search/search-memory-entries)) | Ranked, dated evidence with sources and one status: Supported, Conflicted, NoKnownSupport, UnknownBecauseDegraded |
| Deployment | Apache 2.0 library and self-hosted server, or managed platform ([repo](https://github.com/mem0ai/mem0)) | Managed platform, MIT repo, and Supermemory Local: one self-hostable binary without connectors or the proprietary extraction models ([docs](https://supermemory.ai/docs/self-hosting/overview)) | Managed, or self-hosted in your own Postgres: docker compose, pinned images, same API |
| Pricing model | Meters adds and retrievals: free tier, then $19 and $249 tiers ([pricing](https://mem0.ai/pricing)) | Plan fee plus SM-token usage: $0, $19, $100, $399 tiers with usage credit built in ([pricing](https://supermemory.ai/pricing)) | Managed service, or self-hosted where infrastructure costs are yours |

## Mem0 vs Supermemory: what each system is

Mem0's add call runs messages through an LLM that extracts key facts and preferences, stores them additively, and ranks them at search time ([memory operations](https://docs.mem0.ai/core-concepts/memory-operations)). Its April 2026 algorithm rework made ingestion a single add-only pass with entity linking, and retrieval now combines semantic, keyword, and entity signals ([README](https://github.com/mem0ai/mem0)). The library is Apache 2.0 with about 64,000 GitHub stars as of September 2026, and the managed platform wraps the same design with analytics and graph visualization on paid tiers ([pricing](https://mem0.ai/pricing)).

Supermemory calls itself context infrastructure for AI agents ([docs](https://supermemory.ai/docs)). `POST /v3/documents` accepts a `content` field holding text, a URL, a PDF, an image, or a video, plus `containerTag`, `metadata`, and `documentDate`; processing is asynchronous, with document status starting at queued ([add document](https://supermemory.ai/docs/api-reference/ingest/add-document)). Search takes a `searchMode` of memories, documents, or hybrid ([search API](https://supermemory.ai/docs/api-reference/recall-search/search-memory-entries)). The docs also describe a `withSupermemory()` middleware that injects user profile memories into LLM calls, and memory tools agents can call directly ([docs](https://supermemory.ai/docs/memory-router/overview)). Around the API sit the connectors, a consumer app, and MCP plugins for Claude and coding agents ([repo](https://github.com/supermemoryai/supermemory)).

## What search returns

Mem0 returns ranked memory strings; each result carries `id`, `memory`, `score`, `created_at`, `updated_at`, `categories`, and `metadata` ([search API](https://docs.mem0.ai/api-reference/memory/v2-search-memories)). Supermemory returns `memory` or `chunk` entries with a `similarity` score, `updatedAt`, associated `documents`, an `isAggregated` flag, and a `context` object holding version history and related memories ([search API](https://supermemory.ai/docs/api-reference/recall-search/search-memory-entries)).

The temporal fields mean different things. Mem0's `timestamp` backdates `created_at`, the record time ([API](https://docs.mem0.ai/api-reference/memory/add-memories)). Supermemory's `documentDate` records "when this document's content is from, as opposed to when it was uploaded" ([API](https://supermemory.ai/docs/api-reference/ingest/add-document)), and its research writeup describes grounding on dual timestamps, documentDate and eventDate ([research](https://supermemory.ai/research/longmembench/)). Both documented responses are ranked matches with scores; neither field list includes a claim-level support status.

## Deployment and self-hosting

Mem0 runs three ways: as a pip or npm library in process, as a self-hosted server via Docker Compose, or on the managed platform at app.mem0.ai ([repo](https://github.com/mem0ai/mem0)); the enterprise tier adds on-prem deployment ([pricing](https://mem0.ai/pricing)). Supermemory's MIT repo, about 29,000 stars as of September 2026, contains the API, the consumer app, and Supermemory Local ([repo](https://github.com/supermemoryai/supermemory)). The self-hosting docs describe one self-contained binary, no Docker and no database to provision, serving the full Memory API, while connectors, MCP, and the proprietary extraction models stay cloud-only ([self-hosting](https://supermemory.ai/docs/self-hosting/overview)). The pricing page lists a self-hosted option on the Scale plan and air-gapped deployment on Enterprise ([pricing](https://supermemory.ai/pricing)).

## Pricing

Mem0 meters requests. Free covers 10,000 adds and 1,000 retrievals a month; Starter at $19 covers 50,000 and 5,000; Pro at $249 covers 500,000 and 50,000; enterprise is custom ([pricing](https://mem0.ai/pricing)). Supermemory prices a plan fee with usage credit built in: Free at $0, Pro at $19, Max at $100, Scale at $399, metered in SM tokens at $0.005 per 1,000 SM tokens for plain-text memory and $0.005 per 1,000 search queries; connectors arrive by tier, with Google Drive, Notion, and OneDrive on Pro and Gmail on Max ([pricing](https://supermemory.ai/pricing)). The meters count different things, so price your own corpus and query mix on both.

## Self-published numbers

Mem0's September 2, 2026 post reports 92.5 on LoCoMo, 94.4 on LongMemEval, 64.1 on BEAM at 1M events, 48.6 at 10M, and mean retrieval payloads of 6.7K to 7.0K tokens ([mem0.ai blog](https://mem0.ai/blog/ai-memory-benchmarks-in-2026)). Supermemory reports 95% overall on LongMemEval-S with about 720 mean tokens per query, evaluated in May 2026 ([research](https://supermemory.ai/research/longmembench/)), and maintains MemoryBench, an MIT-licensed harness that runs the same questions, pipeline, and judges across providers ([repo](https://github.com/supermemoryai/memorybench)). The two LongMemEval figures come from different runs, pipelines, and judges. Treat them as separate experiments rather than a head-to-head.

BEAM permits a same-benchmark reading between two of the three columns here. On BEAM's complete splits, past.dev reports 91.50% at 100K events, 86.18% at 1M, and 82.61% at 10M ([/benchmarks](/benchmarks)); mem0 self-publishes 64.1 at 1M and 48.6 at 10M at the link above. We found no BEAM results published by Supermemory as of September 2026. Scoring is documented in the [methodology](/benchmarks/methodology).

## When you want a Supermemory alternative

Which alternative fits depends on the reason for leaving. For per-user conversational memory with an in-process Apache 2.0 library and a large ecosystem, Mem0 is the closest swap in this pair; the wider field is mapped in [mem0 alternatives](/blog/mem0-alternatives). For the same Supermemory API without the cloud, Supermemory Local is its own alternative: one binary, your machine, your model keys ([self-hosting](https://supermemory.ai/docs/self-hosting/overview)). For answers that must arrive with event dates, sources, and an explicit status, the route runs through an evidence store; that design contrast is drawn in [/vs/supermemory](/vs/supermemory).

## How to decide

Run the five tests from the [guide to choosing a memory system](/guides/choose-memory-system).

1. Change a fact, then request the old and new values with dates. Mem0 keeps both rows with record timestamps. Supermemory links versions through the `context` object's history. Check whether dates come back attached to values.
2. Backfill an old export with original timestamps: `timestamp` on Mem0, `documentDate` on Supermemory. Verify out-of-order ingestion sorts correctly at recall.
3. Send three identifiers for one person and check whether they merge. Correct merging is described in the [entity resolution guide](/guides/entity-resolution).
4. Ask a question the store has no basis to answer. Score abstention against confident nearest-neighbor matches.
5. Price your volume on both meters: request counts against SM tokens.

## Where past.dev sits in this comparison

past.dev stores raw text with its original timestamp and answers with evidence. `POST /api/v1/ingest` takes `content` and `timestamp`, entity resolution links references across email, transcripts, tickets, and chat at ingestion, and `POST /api/v1/recall` returns ranked, dated evidence with sources and one of four statuses: Supported, Conflicted, NoKnownSupport, or UnknownBecauseDegraded. Facts carry event time, validity windows, and supersession links, recall is audience-scoped, and deleting a source erases what only it supported. It runs managed or self-hosted in your own Postgres with the same API, holds SOC 2 Type II, ISO 27001, and ISO 27701, and data is exportable. Results are published at [/benchmarks](/benchmarks); integration starts at the [quickstart](/docs/memory-api/quickstart).

Where the others genuinely fit: Supermemory when connector-fed documents and a self-hostable binary are the requirement. Mem0 for per-user personalization from a library you embed. past.dev when the question is what was true, when, and on what evidence.

The deeper design pages live at [/vs/mem0](/vs/mem0) and [/vs/supermemory](/vs/supermemory), with adjacent comparisons at [/vs/zep](/vs/zep) and [/compare/langmem](/compare/langmem).