Exporting Telegram Saved Messages for Personal Backup

Hey team, Darian here. Let’s talk about a workflow that’s saved me more times than I can count: backing up my Telegram “Saved Messages.” I treat that chat like a personal knowledge base—it’s full of code snippets, config files, useful links, and random thoughts. The problem was, finding something from six months ago meant endless scrolling. After wasting an afternoon looking for a specific Nginx directive, I decided to automate an export. Now, I have a searchable, offline CSV of my entire history. It’s a simple setup that provides a massive quality-of-life improvement.

This guide will walk you through setting up a simple Python script to do just that. We’re focusing on efficiency here, so you can set it up and forget it.

Prerequisites

• A Telegram account (obviously).
• Python 3.8 or newer installed on your machine.
• Your personal Telegram API credentials (api_id and api_hash).
• Basic comfort with running Python scripts.

The Guide: Step-by-Step

Step 1: Get Your Telegram API Credentials

First things first, you need to tell Telegram’s servers that your script is a legitimate application. You do this through an API key.

1. Navigate to my.telegram.org and log in with your phone number.
2. Click on “API development tools” and fill out the form. The app title and short name can be anything you like; I just use “BackupScript” for both.
3. Once you submit the form, you’ll immediately get your api_id and api_hash. Keep these safe and secure; treat them like passwords.

Step 2: Project Setup and Dependencies

I’ll skip the standard virtualenv and directory setup since you likely have your own workflow for that. Let’s jump straight to the logic. The main dependency we need is the Telethon library, which is a fantastic async Python client for the Telegram API. In your project environment, you’ll need to install it. Typically, you’d run a command using a package manager like pip to install telethon.

Next, create two files in your project directory:

• config.env: To securely store your API credentials.
• export_saved_messages.py: Our main script.

Populate your config.env file with the credentials you just got. It should look exactly like this:

[telegram]
api_id = YOUR_API_ID_HERE
api_hash = YOUR_API_HASH_HERE
phone_number = YOUR_PHONE_NUMBER_WITH_COUNTRY_CODE

Step 3: The Python Export Script

Now for the core of the operation. Open export_saved_messages.py and let’s build the script. We’ll use the configparser library to read our credentials, csv to write the output file, and Telethon to interact with the API.

Here’s the complete script. I’ve added comments to explain what each part does.

import configparser
import csv
from telethon.sync import TelegramClient
from telethon.tl.types import Message

# --- Configuration Loading ---
# Read API credentials and phone number from our config file.
# This is much better than hardcoding secrets directly in the script.
config = configparser.ConfigParser()
config.read('config.env')

api_id = config.getint('telegram', 'api_id')
api_hash = config.get('telegram', 'api_hash')
phone_number = config.get('telegram', 'phone_number')
session_name = 'telegram_backup_session'
output_csv_file = 'telegram_saved_messages_backup.csv'

# --- Main Logic ---
# Using the 'with' statement ensures the client is properly connected
# and disconnected, even if errors occur.
print("Starting connection to Telegram...")
with TelegramClient(session_name, api_id, api_hash) as client:
    print(f"Client created. Exporting messages to {output_csv_file}...")

    # Open the CSV file for writing. 'w' means we create a new file each time.
    # 'newline' and 'encoding' are best practices for CSV handling.
    with open(output_csv_file, 'w', newline='', encoding='utf-8') as f:
        writer = csv.writer(f)

        # Write the header row for our CSV file.
        writer.writerow(['date', 'message_id', 'message_text'])

        # 'me' is a shortcut in Telethon for your "Saved Messages" chat.
        # We iterate through all messages. Telethon handles the pagination automatically.
        for message in client.iter_messages('me'):
            # We only care about messages with text content for this simple backup.
            if message and message.text:
                writer.writerow([
                    message.date.strftime("%Y-%m-%d %H:%M:%S"),
                    message.id,
                    message.text
                ])

    print(f"Export complete. All text messages have been saved.")

Pro Tip: When you’re first testing this script, you might not want to pull your entire history. You can modify the iter_messages call to include a limit, like client.iter_messages('me', limit=100). This will only fetch the most recent 100 messages, making your test runs much faster.

Step 4: Running the Script

With the files saved, open your terminal in the project directory.

The first time you run the script with python3 export_saved_messages.py, Telethon will prompt you for your phone number, the code Telegram sends you, and your two-factor authentication password if you have one set. It will then create a telegram_backup_session.session file. This file stores your authorization, so you won’t have to log in every time you run the script.

After it finishes, you’ll find a `telegram_saved_messages_backup.csv` file in the same directory, ready to be opened in any spreadsheet program.

Step 5 (Optional): Automating the Backup

In my production setups, I never want to run things manually. For a personal script like this, a simple cron job is perfect. You can set it to run weekly to keep your backup fresh. An example cron entry to run every Monday at 2 AM would be:

0 2 * * 1 python3 export_saved_messages.py

This “set it and forget it” approach ensures your backup is always reasonably up-to-date without any effort on your part.

Common Pitfalls

Here is where I usually see things go wrong, or where I’ve messed up myself in the past:

• The Session File: Do not delete the .session file created by Telethon unless you want to re-authenticate from scratch. If you move your script, move the session file with it.
• Rate Limiting: If you have an enormous number of messages, you might encounter rate limits from Telegram’s API. Telethon is very good about handling these gracefully by waiting, but be aware that the initial export could take a long time.
• Media vs. Text: This script is intentionally simple and only backs up text. Messages that are only an image, video, or file will be skipped. Exporting media requires more complex logic to download the files, which is a great next step if you’re feeling adventurous.

Conclusion

And there you have it. In just a few steps, you’ve created a robust, automated backup system for one of your most valuable digital junk drawers. Having a local, searchable archive of your own notes and saved links is a powerful tool. It decouples your personal knowledge base from a single service and gives you full ownership of the data. I hope this helps you be a little more organized and saves you from a future headache.

All the best,
Darian Vance

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions