DEV Community: Mohammad

Telegram Forwarder: Automate Message Forwarding Between Telegram Chats Using Python & Telethon

Mohammad — Mon, 04 Aug 2025 05:33:17 +0000

Have you ever wished you could automatically forward messages from one Telegram chat, group, or channel to another? Whether you're managing multiple communities, archiving content, or syncing information across channels, manually copying and pasting messages is neither scalable nor efficient.

That’s where Telegram Forwarder comes in — a lightweight, powerful Python script that uses the Telethon library to automate Telegram message forwarding.

What is Telegram Forwarder?

Telegram Forwarder is a Python-based script designed to:

Automatically forward messages from one or more Telegram sources to one or more destinations
Support one-to-one, one-to-many, and many-to-one forwarding
Work with user accounts and bot accounts
Optionally remove the "Forwarded from..." signature
Handle Telegram API rate limits gracefully
Offer comprehensive logging and easy configuration via .env file

This script is ideal for admins, content curators, automation fans, and anyone working with Telegram as a core communication tool.

Key Features

Forward from any source: Private chats, public channels, or groups
Multi-source and multi-destination support
Bot or user login support
Clean forwards: Option to remove forward signatures
Quiet mode: Turn off console output for clean logging
Robust logging: Track everything in telegram_forwarder.log
.env configuration: No need to modify Python files

Installation Guide

Clone the repo and install dependencies:

git clone https://github.com/Linuxmaster14/TGForwarder.git
cd TGForwarder
pip install -r requirements.txt

Set up your .env file:

cp .env.example .env

Now, edit .env and add your credentials and chat IDs.

Prerequisites

Before you start, you’ll need:

Telegram API Credentials: Get API_ID and API_HASH from my.telegram.org
Bot Token (optional): Get it from @BotFather
Chat IDs: Use @userinfobot or @get_id_bot to fetch them.

Author

Made with ❤️ by Linuxmaster14

Introducing Telepipe: Your New Favorite CLI for Telegram Notifications & File Sharing

Mohammad — Mon, 19 May 2025 20:51:53 +0000

Level up your command-line productivity with Telepipe, a nifty utility that bridges your terminal directly to your Telegram chats!

Are you a developer, sysadmin, or just someone who practically lives in the terminal? Ever wished for a super simple way to send quick messages, command outputs, or even entire files to a Telegram chat, group, or channel without breaking your workflow? If so, Telepipe is the tool you've been waiting for.

What is Telepipe?

Telepipe is a simple command-line utility to send messages or files to Telegram chat directly from your terminal. Whether you want to get notifications from your scripts, share log files, or just pipe the output of a command, Telepipe handles it seamlessly.

The Pain Point: Terminal-to-Telegram Bridging

Often, you're working on a server or deep in your local development environment, and you need to quickly share information. Maybe a long-running script has finished, a backup has completed (or failed!), or you just want to send a text snippet. Switching to a GUI app or fumbling with complex API calls can be a drag. Telepipe eliminates this friction.

Key Features of Telepipe:

Versatile Messaging: Send messages to Telegram channel/chat/group directly from command line.
Smart File Handling: Automatically switch between message and file mode based on content length. The default threshold is 4096 characters, but this is configurable.
Shareable Links: Generate shareable Telegram links.
Guided Installation: Easy installation with guided setup. The installer.sh script walks you through the setup, including dependency checks (it needs curl).
Simple Configuration: A straightforward configuration file (/etc/telepipe/config) holds your Bot Token, Chat ID, and other preferences.
Customizable: You can set:
- BOT_TOKEN: Your unique Telegram Bot Token from BotFather.
- CHAT_ID: The target chat, group, or channel ID.
- MAX_LEN: The character limit before switching to file mode (defaults to 4096).
- TIMEOUT: API request timeout in seconds (defaults to 5).
- DISABLE_LINK_PREVIEW: Option to disable link previews in messages (defaults to true).

How it Works (Under the Hood)

Telepipe is a Bash script that uses curl to interact with the Telegram Bot API. During installation, it prompts you for your Bot Token and Chat ID, storing them securely in a configuration file. When you pipe data to Telepipe or use it with cat, it reads the standard input, checks the length, and then constructs the appropriate API request to either send a message or upload a document.

Installation Made Easy

Getting Telepipe up and running is simple:

Clone the Repository:

git clone https://github.com/linuxmaster14/telepipe.git
cd telepipe

Run the Installer:

chmod +x installer.sh
sudo ./installer.sh

The installer will:
* Check if you're running as root/sudo.
* Create necessary directories (/etc/telepipe, /usr/local/bin).
* Check for and offer to install curl if it's missing.
* Prompt you for your Telegram Bot Token and Chat ID.
* Allow you to customize MAX_LEN, TIMEOUT, and DISABLE_LINK_PREVIEW settings.
* Create the configuration file (/etc/telepipe/config) and the main telepipe script in /usr/local/bin.
* Set appropriate permissions for the script and config file (config is chmod 600).
* Test the connection to the Telegram API.

Using Telepipe - It's a Pipe Dream!

The beauty of Telepipe lies in its simplicity, leveraging standard Unix pipes:

Show Help:
```
telepipe --help
```
Show Version:
```
telepipe --version
```

Send a Simple Message:

echo "Hello from my server!" | telepipe

Send Command Output:
```
uptime | telepipe
```
Send File Contents:
```
cat my_log_file.txt | telepipe
```

Integrate into Your Scripts:

backup_my_database() {
  # Your backup logic here...
  if [ $? -eq 0 ]; then
    echo "Database backup completed successfully at $(date)" | telepipe
  else
    echo "Database backup FAILED at $(date)!" | telepipe
  fi
}

Upon successful sending, Telepipe will output a shareable Telegram link to the message or indicate success if it's a direct message.

Configuration Details

You can tweak Telepipe's behavior by editing /etc/telepipe/config:

BOT_TOKEN: Your Telegram bot token (get from @botfather on Telegram).
CHAT_ID: The ID of the chat, group, or channel. For channels/groups, this often starts with -100.
MAX_LEN: Max message length before sending as a file (default: 4096).
TIMEOUT: API request timeout in seconds (default: 5).
DISABLE_LINK_PREVIEW: Whether to disable link previews (default: true).

Why Telepipe?

Simplicity: No complex dependencies or bloated clients. Just a Bash script and curl.
Efficiency: Stay in your terminal and automate notifications with ease.
Flexibility: Send anything from simple text to entire files.
Open Source: Licensed under MIT, so feel free to use, modify, and contribute!

Get Started with Telepipe Today!

Stop context-switching and start integrating Telegram seamlessly into your command-line workflows.

Find it on GitHub: https://github.com/Linuxmaster14/telepipe

Contributions, feedback, and feature requests are always welcome!

Understanding SSD Endurance: What Does TBW Really Mean?

Mohammad — Sat, 17 May 2025 03:31:17 +0000

If you're using an SSD — and let’s be honest, you probably are — you might have come across a spec labeled TBW, or Terabytes Written. But what does it actually mean for the real-world lifespan of your drive?

Let’s break it down in simple terms.

What is TBW?

TBW stands for Terabytes Written, and it’s a metric that tells you how much data can be written to an SSD before the drive is likely to start wearing out. Think of it like a fuel limit — not for how long the drive will exist, but for how much write work it can handle over its lifetime.

For example, if your SSD has a TBW of 600, that means you can write 600 terabytes of data to it before you start entering the "wear-out" zone, as defined by the manufacturer.

So... How Long Will My SSD Last?

Let’s do a quick, real-world calculation.

Say you're a regular user writing about 100 GB per day — downloading files, installing apps, updating your system, working on projects. That’s quite a bit for a typical user, but let’s go with it.

100 GB/day = 36.5 TB/year
600 TBW / 36.5 TB/year ≈ 16 years

Yes, sixteen years of daily 100GB writing. That’s how much endurance a 600TBW SSD gives you. And if you write less than that (which most people do), it’ll last even longer.

How to Check TBW on Your SSD

You can monitor your SSD’s health and total data written using tools like:

CrystalDiskInfo (Windows)
smartctl from smartmontools (Linux/macOS)

These tools can show you how much data has been written so far, so you can get a real-time sense of your drive’s life expectancy.

Final Thoughts

TBW is an important but often misunderstood metric. SSDs don’t just suddenly die after hitting the limit, but the risk of data loss increases as the flash memory wears out. That said, for most users — even power users — modern SSDs offer years of reliable performance.

So the next time you see a TBW rating, don’t panic. Unless you're stress-testing your drive daily, you're probably fine for a decade or more.