mem0/docs/cookbooks/essentials/exporting-memories.mdx

---
title: Export Stored Memories
description: "Retrieve, review, and migrate user memories with structured exports."
---


Mem0 is a dynamic memory store that lets you retrieve memories as raw records or transform them into a structured export for downstream use.

This cookbook shows you how to retrieve and export your data for inspection, migration, or compliance.

<Warning>
The structured export job is not a raw backup. It uses the schema and instructions you provide to transform matching memories. Use paginated `get_all()` calls when you need the original memory records. For an account-level data access or compliance request that the API cannot complete, contact support.
</Warning>

---

## Setup

```python
from mem0 import MemoryClient

client = MemoryClient(api_key="your-api-key")

```

<Note>
Your API key needs export permissions to download memory data. Check your project settings on the <a href="https://app.mem0.ai?utm_source=oss&utm_medium=cookbook-exporting-memories" rel="nofollow">dashboard</a> if export operations fail with authentication errors.
</Note>

Let's add some sample memories to work with:

```python
# Dev's work history
client.add(
    "Dev works at TechCorp as a senior engineer",
    user_id="dev",
    metadata={"type": "professional"}
)

# Arjun's preferences
client.add(
    "Arjun prefers morning meetings and async communication",
    user_id="arjun",
    metadata={"type": "preference"}
)

# Carl's project notes
client.add(
    "Carl is leading the API redesign project, targeting Q2 launch",
    user_id="carl",
    metadata={"type": "project"}
)

```

---

## Getting All Memories

Use `get_all()` with filters to retrieve everything for a specific user:

```python
dev_memories = client.get_all(
    filters={"user_id": "dev"},
    page=1,
    page_size=50
)

print(f"Total memories: {dev_memories['count']}")
print(f"First memory: {dev_memories['results'][0]['memory']}")

```

**Output:**

```
Total memories: 1
First memory: Dev works at TechCorp as a senior engineer

```

<Info>
**Expected output:** `get_all()` retrieved Dev's complete memory record. This method returns everything matching your filters: no semantic search, no ranking, just raw retrieval. Perfect for exports and audits.
</Info>

You can filter by metadata to get specific types:

```python
carl_projects = client.get_all(
    filters={
        "AND": [
            {"user_id": "carl"},
            {"metadata": {"type": "project"}}
        ]
    }
)

for memory in carl_projects['results']:
    print(memory['memory'])

```

**Output:**

```
Carl is leading the API redesign project, targeting Q2 launch

```

---

## Searching Memories

When you need semantic search instead of retrieving everything, use `search()`:

```python
results = client.search(
    query="What does Dev do for work?",
    filters={"user_id": "dev"},
    top_k=5
)

for result in results['results']:
    print(f"{result['memory']} (score: {result['score']:.2f})")

```

**Output:**

```
Dev works at TechCorp as a senior engineer (score: 0.89)

```

Search works across all memory fields and ranks by relevance. Use it when you have a specific question; use `get_all()` when you need everything.

---

## Exporting to Structured Format

For migrations or compliance, you can export memories into a structured schema using Pydantic-style JSON schemas.

### Step 1: Define the schema

```python
professional_profile_schema = {
    "properties": {
        "full_name": {
            "type": "string",
            "description": "The person's full name"
        },
        "current_role": {
            "type": "string",
            "description": "Current job title or role"
        },
        "company": {
            "type": "string",
            "description": "Current employer"
        }
    },
    "title": "ProfessionalProfile",
    "type": "object"
}

```

### Step 2: Create export job

```python
export_job = client.create_memory_export(
    schema=professional_profile_schema,
    filters={"user_id": "dev"}
)

print(f"Export ID: {export_job['id']}")
print(f"Status: {export_job['status']}")

```

**Output:**

```
Export ID: exp_abc123
Status: processing

```

<Info>
**Export initiated:** Status is "processing". Large exports may take a few seconds. Poll with `get_memory_export()` until status changes to "completed" before downloading data.
</Info>

### Step 3: Download the export

```python
# Get by ID
export_data = client.get_memory_export(
    memory_export_id=export_job['id']
)

print(export_data['data'])

```

**Output:**

```json
{
  "full_name": "Dev",
  "current_role": "senior engineer",
  "company": "TechCorp"
}

```

You can also retrieve exports by filters:

```python
# Get latest export matching filters
export_by_filters = client.get_memory_export(
    filters={"user_id": "dev"}
)

print(export_by_filters['data'])

```

---

## Adding Export Instructions

Guide how Mem0 resolves conflicts or formats the export:

```python
export_with_instructions = client.create_memory_export(
    schema=professional_profile_schema,
    filters={"user_id": "arjun"},
    export_instructions="""
1. Use the most recent information if there are conflicts
2. Only include confirmed facts, not speculation
3. Return null for missing fields rather than guessing
"""
)

```

<Tip>
Always check export status before downloading. Call `get_memory_export()` in a loop with a short delay until `status == "completed"`. Attempting to download while still processing returns incomplete data.
</Tip>

---

## Platform Export

You can also export memories directly from the Mem0 platform UI:

1. Navigate to **Memory Exports** in your project dashboard
2. Click **Create Export**
3. Select your filters and schema
4. Download the completed export as JSON

This is useful for one-off structured exports or manual data reviews. It does not create a raw backup of every memory record; use paginated `get_all()` calls for raw retrieval.

<Warning>
Exported data expires after 7 days. Download and store exports locally if you need long-term archives. After expiration, you'll need to recreate the export job.
</Warning>

---

## What You Built

A complete memory export system with multiple retrieval methods:

- **Bulk retrieval (get_all)** - Fetch all memories matching filters for comprehensive audits
- **Semantic search** - Query-based lookups with relevance scoring
- **Structured exports** - Pydantic-schema exports for migrations and compliance
- **Export instructions** - Guide conflict resolution and data formatting
- **Platform UI exports** - One-off manual downloads via dashboard

These approaches support data inspection, portability workflows, system migrations, and manual reviews. Use raw retrieval or contact support when a compliance request requires the original records rather than a schema-transformed export.

---

## Summary

Use **`get_all()`** for paginated raw retrieval, **`search()`** for specific questions, and **`create_memory_export()`** for schema-transformed data. Structured exports expire after 7 days, so download completed results promptly. Do not treat them as raw backups.

<CardGroup cols={2}>
  <Card title="Build a Mem0 Companion" icon="users" href="/cookbooks/essentials/building-ai-companion">
    Learn core memory patterns including temporary vs permanent data handling.
  </Card>
  <Card title="Control Memory Ingestion" icon="filter" href="/cookbooks/essentials/controlling-memory-ingestion">
    Ensure only verified insights make it into your export pipeline.
  </Card>
</CardGroup>

<Snippet file="star-on-github.mdx" />