How to Clone a Telegram Channel to a Second Account in 2026

what you will end up with

Finish this guide and you’ll have a cloned Telegram channel: all historical content replicated to a destination channel, with a bot relay keeping new posts in sync automatically. The full job takes 30 minutes for small channels and several hours for anything above 5,000 messages. You need admin rights on the source channel, a second Telegram account on a separate phone number that is at least 3-4 days old, and either a Python environment or access to a persistent hosting session. No root access, no third-party apps with shady permissions.

before you start

You need two Telegram accounts on separate phone numbers. The second account must be at least 72 hours old. Fresh accounts get hard rate-limited on virtually every API action, and Telegram’s anti-spam layer treats a brand-new account doing bulk forwarding as an immediate threat. Use Telegram Desktop 5.x or the official Android/iOS client on both accounts. Some channel admin options do not appear in Telegram Web, so avoid the browser client for the management steps. You also need Python 3.10 or higher on the machine that will run the clone script, plus your api_id and api_hash from the Telegram developer portal at my.telegram.org.

# check your environment before starting
python3 --version        # must be 3.10 or higher
pip3 show pyrogram       # if blank: pip3 install pyrogram tgcrypto
pip3 show tgcrypto       # tgcrypto is required for speed and stability

the step-by-step

The method: add the second account as co-admin of the source channel, create the destination channel on the second account, clone historical content with a Pyrogram script, then keep it live with a bot relay. This is the most reliable way to clone a Telegram channel without burning either account in the process.

1. Add the second account as co-admin of the source channel. Open the source channel in Telegram Desktop while logged in as the original owner. Go to Manage Channel, then Administrators, then Add Administrator. Search for the second account by username. You need to share at least one group with the second account for the lookup to work. If you cannot find it, create a throwaway private group, add both accounts to it, then retry. Grant the second account “Post Messages,” “Edit Messages,” and “Invite Users via Link” permissions. Do not grant “Delete Messages” yet. You do not need it, and the narrower permission set looks less automated.

2. Create the destination channel on the second account. On a separate device or in a private browser window, log in as the second account. Create a new channel with the same name and description as the source. Match the privacy setting exactly. If the source is public, grab the same username immediately or a close variant before someone else does. If the source is private, generate a fresh invite link after creation and save it.

3. Create a bot token for the relay. Message @BotFather and run /newbot. Give it a name, get the API token. Then add this bot as admin of both channels: it needs “Read Messages” access in the source (adding it as a regular member works) and “Post Messages” admin rights in the destination. This bot will keep the clone live after the historical migration is done.

4. Clone the historical content. This is where most guides gloss over the real work. The script below iterates through the source channel’s message history and forwards each message to the destination. Run it using the second account’s Pyrogram session so the destination channel receives the messages as a proper admin post, not a forwarded-from label.

import asyncio
from pyrogram import Client
from pyrogram.errors import FloodWait

API_ID = 12345678           # from my.telegram.org
API_HASH = "your_api_hash"
SOURCE = "@source_channel"
DEST   = "@destination_channel"
SLEEP  = 2.0                # seconds between forwards, do not drop below 1.5

async def clone_channel():
    async with Client("second_account_session", api_id=API_ID, api_hash=API_HASH) as app:
        async for msg in app.get_chat_history(SOURCE, reverse=True):
            try:
                await app.forward_messages(DEST, SOURCE, msg.id)
                await asyncio.sleep(SLEEP)
            except FloodWait as fw:
                print(f"FloodWait: sleeping {fw.value}s")
                await asyncio.sleep(fw.value + 5)
            except Exception as e:
                print(f"skipped message {msg.id}: {e}")

asyncio.run(clone_channel())

The reverse=True flag processes oldest messages first, which keeps the destination timeline in the right order. The FloodWait catch is not optional. Drop it and Telegram will pause you for anywhere from 60 seconds to 24 hours depending on how fast you pushed. Log the skipped message IDs so you can rerun just the gaps afterward. Service messages, polls, and some live-stream events cannot be forwarded and will always skip cleanly.

1. Handle the member migration. Expectations need to be realistic here. Telegram does not let you force-subscribe users to a channel. Attempting to bulk-add members via the API without their action triggers PeerFloodError and typically gets the account restricted within minutes. The right mechanic is the invite link. Pin a message in the source channel pointing to the new channel. If you run a linked discussion group, post the announcement there too. For private channels, message your key members directly with the new invite link. The migration of the audience is a content and communication problem, not a script problem.

2. Wire up the bot relay for ongoing sync. With the historic content in place, configure your bot to auto-forward new posts. The simplest production-ready option is running a Pyrogram listener on the same hosting session: register a @app.on_message(filters.channel & filters.chat(SOURCE)) handler and have it forward each incoming message to the destination. If you want something no-code, some public relay bots on Telegram handle this, but give them only the minimum admin permissions and read their terms before handing over channel access.

3. Transfer ownership to the second account (optional). If the goal is a full migration rather than a permanent mirror, go back to the source channel as the original owner and tap the second account’s entry under Administrators. Choose “Transfer Ownership.” Telegram requires you to confirm with your Two-Step Verification password or a code sent to your phone. After this, the original account becomes a regular admin. The source channel now belongs to the second account. Do this only after the content clone is verified complete.

4. Verify the relay is live. Post a test message in the source channel. It should appear in the destination within 5-10 seconds if the bot or listener is running. Check that photos, videos, and documents replicate correctly. Video forwarding sometimes fails if the file exceeds the bot’s upload size limit (2 GB for bots via the standard API). For large video channels, you may need to use a user-session relay instead of a bot token.

what can go wrong

FloodWait on the clone script. The error reads FloodWait: A wait of X seconds is required. This is Telegram telling you to slow down, not a ban. The script above catches it automatically, but if you ran a different script without handling it, stop everything, wait out the timer, then restart with a higher sleep value. Starting at 3 seconds per message is safe for most accounts. Drop below 1 second and you are gambling.

Second account gets banned mid-clone. This happens most often when the account is too new or when the session IP has a poor reputation with Telegram’s risk scoring. See why Telegram bans accounts for the full mechanics. If the account gets banned, check @SpamBot first: sometimes it is a temporary restriction, not a full ban. Wait 24-48 hours before retrying, and retry from a different IP. Do not rerun the same script from the same address immediately.

“User not mutual contact” error when adding co-admin. The account lookup in Telegram’s admin flow requires shared history. Fix: create any group, add both accounts, then retry the admin add. Takes two minutes and always works.

Bot stops forwarding after the source channel owner edits a post. Most simple relay setups only handle new_message events. Edits do not propagate. If your source channel frequently edits posts after publishing (corrections, updated links), switch to a listener that also handles edited_message events, or accept that edits will not sync.

how this looks on managed hosting

When the Telegram session lives on a telegramvault cloud phone, the clone process changes in a few concrete ways. The Pyrogram script runs directly on the Android device in a persistent terminal session, which means the API calls originate from a real Singapore mobile IP on SingTel, M1, or StarHub, not your home broadband or a VPS. Telegram’s anti-spam scoring treats activity from known mobile network ASNs differently from data center or residential proxy ASNs. In practice, this means fewer FloodWait interruptions and a much lower probability of the session getting flagged mid-clone. The browser-based STF interface lets you watch the device screen in real time, so you can monitor the script output without SSH. You also avoid the most common failure mode in DIY setups: the local machine going to sleep or losing connectivity halfway through a 10,000-message migration and leaving the destination channel in a half-cloned state.

The dedicated vs shared mobile IP question matters here too. A session running on a dedicated SIM with a static IP that has never been associated with spam behaves very differently from a session on a rotated residential pool. When the IP has clean history, Telegram’s flood thresholds are noticeably more forgiving.

recovery if you mess up

If the clone script ran and left the destination channel in a broken state (duplicated messages, wrong order, partial history), the cleanest path is to delete the destination channel and start over. Before you do that, run a quick Pyrogram script with delete_messages to wipe it programmatically, which is faster than manual deletion. Then restart the clone from the beginning with a corrected sleep interval.

If ownership transfer failed or the original account lost access unexpectedly during the process, the account recovery path goes through Telegram’s in-app support form. Telegram’s official support FAQ documents the escalation steps. Be prepared to wait 3-7 business days for a response. That is the realistic range, not a worst case. Keep the original account’s phone number, last login date, and any 2FA recovery codes documented somewhere offline before you start any ownership transfer.

If the second account gets permanently banned during migration and you had not completed the ownership transfer, the original account still holds the source channel. Start the process again with a third account once the appeal window closes on the banned one. Frustrating, but recoverable. The only unrecoverable scenario is losing access to the original account and the destination before either is verified, so keep the original account active throughout the entire process.

related tasks

Running a proper channel backup. To clone a Telegram channel for redundancy purposes, keep the destination channel private and treat it as a read-only archive rather than a live mirror. This protects against channel takedowns, which happen in patterns that Access Now’s #KeepItOn coalition has documented across dozens of countries. A private archived clone costs you nothing extra and gives you full recovery options if the primary channel disappears.

Multi-channel operations across several accounts. Once the single-channel clone pipeline is working, the natural next step is running it across 5-10 channels simultaneously. Each clone needs its own session on a distinct IP, because Telegram correlates API behavior across sessions sharing the same address. At that scale, per-channel dedicated sessions become the only practical approach, which is what the Singapore Mobile Proxy plans infrastructure is designed for.

Understanding the API rate limits in depth. The FLOOD_WAIT_X and PEER_FLOOD errors the script encounters are documented, albeit incompletely, in Telegram’s official MTProto API error reference. The limits are not published as fixed numbers because Telegram adjusts them dynamically based on account age, IP history, and recent activity patterns. Reading the error documentation before starting a large clone gives you a realistic picture of what triggers each error class and how to avoid the common ones by design rather than by luck.

Automating content republishing after a clone. Cloning a Telegram channel to a second account is usually step one of a larger workflow: the second account then cross-posts to other platforms, schedules content batches, or feeds a bot pipeline. Telegram’s Bot API documentation covers the forwardMessage and copyMessage methods that underpin most of these downstream automations. The distinction between the two matters: forwardMessage preserves the source attribution header, copyMessage does not.

final word

Cloning a Telegram channel to a second account is a routine operational task when you approach it methodically, pick the right sleep intervals, and run the session from an IP with clean history. Rush any of those three things and Telegram’s risk systems will end the job for you. If you want the session managed on dedicated mobile hardware with a Singapore SIM from day one, the telegramvault waitlist is open now.