Last updated: March 16, 2026

To export your Gemini workspace data before switching to Claude Team, use Google Takeout at takeout.google.com to download your conversation history, custom Gems, and settings as JSON files. Back up your configuration, parse the exported JSON programmatically if needed, and document your custom instructions and prompts so you can recreate them in Claude. The process takes minutes to set up, though Google may need hours to prepare large archives.

Table of Contents

Why Export Your Gemini Workspace Data

Your Gemini workspace contains more than just chat logs. Depending on your subscription level, you have accumulated conversation threads, custom instructions, project-specific contexts, and possibly integrated code or documents. Before you cancel your subscription or reduce access, retrieving this data ensures continuity in your work.

Developers and power users especially benefit from exporting conversation history because those threads often contain debugging sessions, architectural discussions, and code generation that you may want to reference later.

There is also a practical timing consideration: once your Gemini subscription lapses, you may lose access to Gems you created, shared prompts, and older conversation threads depending on your account type. Export before canceling, not after.

What Data You Can Export

Google Gemini provides several data export options depending on your workspace type:

Consumer Accounts (gemini.google.com):

Google Workspace / Google One:

The export process uses Google Takeout, which provides your data in JSON format. This means your exported conversations remain readable and searchable.

Step-by-Step Export Process

Step 1: Access Google Takeout

Navigate to Google Takeout and sign in with the account connected to your Gemini subscription. You will see a list of Google services that store your data.

Step 2: Select Gemini Data

Scroll through the service list and find “Gemini”. If you do not see it explicitly listed, check under “Other Google services” or “Cloud Storage” depending on how your data is stored. Google periodically updates which products appear in Takeout, so if Gemini is not visible, check the “Select all” option for a complete archive.

# After downloading, your Takeout archive structure looks like:
# takeout-YYYYMMDD/
# └── Google Products/
#     └── Gemini/
#         ├── conversations.json
#         ├── gems.json
#         └── settings.json

Step 3: Choose Export Format and Frequency

Select your preferred delivery method. You can choose to receive a download link via email, add files to Google Drive, or send to cloud storage providers. Decide between a one-time export or scheduled exports if you want ongoing backups.

Step 4: Download and Verify

Once Google prepares your archive (this may take minutes to hours depending on data volume), download the ZIP file. Verify the contents include what you expect before deleting from your account.

Extracting Conversations Programmatically

If you have large conversation histories or want to process them further, you can parse the exported JSON:

import json
from pathlib import Path

def extract_gemini_conversations(takeout_path: str) -> list[dict]:
    """Parse exported Gemini conversations from Google Takeout."""

    gemini_path = Path(takeout_path) / "Google Products" / "Gemini"
    conversations = []

    # Load the main conversations file
    conversations_file = gemini_path / "conversations.json"
    if conversations_file.exists():
        with open(conversations_file, 'r', encoding='utf-8') as f:
            data = json.load(f)
            conversations = data.get('conversations', [])

    return conversations

def format_for_readability(conversations: list[dict]) -> str:
    """Format conversations for easy reading or import."""

    output = []
    for conv in conversations:
        title = conv.get('title', 'Untitled')
        messages = conv.get('messages', [])

        output.append(f"\n## {title}\n")

        for msg in messages:
            role = msg.get('role', 'unknown')
            content = msg.get('content', '')
            timestamp = msg.get('timestamp', '')

            output.append(f"[{role.upper()}] {timestamp}")
            output.append(f"{content}\n")

    return "\n".join(output)

# Usage example
if __name__ == "__main__":
    convs = extract_gemini_conversations("/path/to/takeout")
    formatted = format_for_readability(convs)

    with open("gemini_conversations.md", "w") as f:
        f.write(formatted)

This script converts your JSON export into markdown, making it easy to search through past conversations or import them into other tools.

Exporting Custom Gems and Instructions

If you have created custom Gems (Gemini’s version of customized AI behaviors), export those separately:

def export_gems(gemini_path: str) -> dict:
    """Extract custom Gem configurations."""

    gems_file = Path(gemini_path) / "gems.json"

    if gems_file.exists():
        with open(gems_file, 'r') as f:
            return json.load(f)

    return {}

# Example output structure
# {
#     "gems": [
#         {
#             "name": "Code Reviewer",
#             "description": "Reviews code for bugs and style issues",
#             "instructions": "You are a senior developer...",
#             "tools": ["web_search", "code_execution"]
#         }
#     ]
# }

Document these custom instructions manually, as they represent valuable workflows you may want to recreate in Claude.

Recreating Gems as Claude Projects

Claude Team uses Projects instead of Gems. A Project is a persistent workspace with custom instructions, uploaded files, and shared conversation history for your team. The mapping from Gemini Gems to Claude Projects is fairly direct:

Gemini Gem Feature Claude Project Equivalent
Custom instructions Project system prompt
Tool access (web search) Claude’s built-in web search
Tool access (code execution) Claude’s built-in code execution
Shared prompts Shared project instructions
Name and description Project name and description

To recreate a Gem as a Claude Project:

  1. Open Claude Team and create a new Project
  2. Paste the Gem’s system instructions into the Project instructions field
  3. Upload any reference documents the Gem depended on
  4. Invite the relevant team members to the Project

For Gems that used Google-specific tool integrations (Google Docs, Sheets, Drive), you will need alternative approaches in Claude since direct Google Workspace integration works differently. Claude can read documents you upload directly, or you can use copy-paste workflows.

Searching and Indexing Your Exported History

After exporting, your Gemini conversation history can become a searchable reference library. Use tools like ripgrep or build a simple search interface:

import sqlite3
import json
from pathlib import Path

def index_conversations(conversations: list[dict], db_path: str = "gemini_history.db"):
    """Index conversations in SQLite for fast search."""
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()

    cursor.execute("""
        CREATE TABLE IF NOT EXISTS messages (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            conversation_title TEXT,
            role TEXT,
            content TEXT,
            timestamp TEXT
        )
    """)

    for conv in conversations:
        title = conv.get('title', 'Untitled')
        for msg in conv.get('messages', []):
            cursor.execute(
                "INSERT INTO messages (conversation_title, role, content, timestamp) VALUES (?, ?, ?, ?)",
                (title, msg.get('role'), msg.get('content'), msg.get('timestamp'))
            )

    conn.commit()
    conn.close()
    print(f"Indexed {len(conversations)} conversations")

def search_history(query: str, db_path: str = "gemini_history.db"):
    """Full-text search across conversation history."""
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    cursor.execute(
        "SELECT conversation_title, role, content FROM messages WHERE content LIKE ? LIMIT 20",
        (f"%{query}%",)
    )
    results = cursor.fetchall()
    conn.close()
    return results

This gives you a local, searchable archive of all your Gemini work—useful when you need to recall how you solved a specific problem months ago.

Preserving Context for Claude Migration

When switching to Claude Team, you cannot directly import Gemini conversations. However, you can preserve the value:

  1. Convert conversations to markdown using the script above

  2. Create a context document summarizing key projects and decisions

  3. Document custom prompts that worked well in Gemini

  4. Export code snippets that Gemini helped generate

# Migration Context - Gemini to Claude

## Projects Worked On
- Project A: E-commerce API with Python/FastAPI
- Project B: React dashboard with TypeScript

## Useful Custom Instructions
- "Explain code like I'm a junior developer"
- "Focus on performance and scalability"

## Recurring Patterns
- Frequently asked about Docker configurations
- Used Gemini for SQL query optimization

What Cannot Be Exported

Some Gemini data remains inaccessible:

Check Google’s official Takeout documentation for the most current export capabilities.

Best Practices Before Switching

Before canceling your Gemini subscription:

  1. Download all exports - Verify you have complete archives

  2. Screenshot saved settings - Some configurations may not appear in exports

  3. Export separately - Use both Takeout and manual copy-paste for critical data

  4. Test restoration - Confirm you can read and search your exported data

  5. Keep local backups - Store exports in multiple locations

  6. Overlap subscriptions briefly - Consider keeping both active for 1-2 weeks during the transition to catch anything you missed

Frequently Asked Questions

How long does it take to export gemini workspace data before switching?

For a straightforward setup, expect 30 minutes to 2 hours depending on your familiarity with the tools involved. Complex configurations with custom requirements may take longer. Having your credentials and environment ready before starting saves significant time.

What are the most common mistakes to avoid?

The most frequent issues are skipping prerequisite steps, using outdated package versions, and not reading error messages carefully. Follow the steps in order, verify each one works before moving on, and check the official documentation if something behaves unexpectedly.

Do I need prior experience to follow this guide?

Basic familiarity with the relevant tools and command line is helpful but not strictly required. Each step is explained with context. If you get stuck, the official documentation for each tool covers fundamentals that may fill in knowledge gaps.

Can I adapt this for a different tech stack?

Yes, the underlying concepts transfer to other stacks, though the specific implementation details will differ. Look for equivalent libraries and patterns in your target stack. The architecture and workflow design remain similar even when the syntax changes.

Where can I get help if I run into issues?

Start with the official documentation for each tool mentioned. Stack Overflow and GitHub Issues are good next steps for specific error messages. Community forums and Discord servers for the relevant tools often have active members who can help with setup problems.

Built by theluckystrike — More at zovo.one