Playlist Free - Telegram Bot To Download Youtube

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE): """Send welcome message""" welcome_text = """ 🎬 YouTube Playlist Downloader Bot

Send me a YouTube playlist URL and I'll download it for you!

Commands: /start - Show this message /help - Get help /cancel - Cancel current download /mode - Change download mode (Audio/Video)

Features: • Download entire playlists • Choose audio or video format • Progress tracking • Cancel any time

How to use:

Limits: • Max 50MB per file (Telegram limit) • Files larger than 50MB will be skipped """ await update.message.reply_text(welcome_text, parse_mode='Markdown') telegram bot to download youtube playlist free

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE): """Send help message""" help_text = """ How to use this bot:

1️⃣ Send a YouTube URL

2️⃣ Choose mode

3️⃣ Wait for download

4️⃣ Receive files

Tips: • Use /mode to set default preference • Download status is shown in real-time • Files are automatically deleted after sending """ await update.message.reply_text(help_text, parse_mode='Markdown')

async def cancel(update: Update, context: ContextTypes.DEFAULT_TYPE): """Cancel ongoing download""" user_id = update.effective_user.id

if user_id in user_sessions:
    user_sessions[user_id]['cancel'] = True
    await update.message.reply_text("❌ Download cancelled. Cleaning up...")
    await delete_download_folder(user_id)
    del user_sessions[user_id]
else:
    await update.message.reply_text("No active download to cancel.")

async def set_mode(update: Update, context: ContextTypes.DEFAULT_TYPE): """Set download mode preference""" keyboard = [ [ InlineKeyboardButton("🎵 Audio (MP3)", callback_data="mode_audio"), InlineKeyboardButton("🎬 Video (MP4)", callback_data="mode_video") ] ] reply_markup = InlineKeyboardMarkup(keyboard) await update.message.reply_text( "Select download mode:", reply_markup=reply_markup )

async def handle_url(update: Update, context: ContextTypes.DEFAULT_TYPE): """Handle YouTube URL""" user_id = update.effective_user.id url = update.message.text.strip()

# Check if it's a YouTube URL
if not ('youtube.com' in url or 'youtu.be' in url):
    await update.message.reply_text("❌ Please send a valid YouTube URL.")
    return
# Check if already downloading
if user_id in user_sessions:
    await update.message.reply_text("⚠️ You have an active download. Use /cancel first.")
    return
# Show options
keyboard = [
    [
        InlineKeyboardButton("🎵 Download Audio (MP3)", callback_data=f"audio_url"),
        InlineKeyboardButton("🎬 Download Video (MP4)", callback_data=f"video_url")
    ],
    [InlineKeyboardButton("❌ Cancel", callback_data="cancel")]
]
reply_markup = InlineKeyboardMarkup(keyboard)
await update.message.reply_text(
    "📥 Choose download type:",
    reply_markup=reply_markup
)

async def download_playlist(url: str, user_id: int, mode: str, update: Update): """Download playlist and send files""" status_msg = await update.message.reply_text("📊 Getting playlist information...") async def start(update: Update, context: ContextTypes

try:
    # Get playlist info
    info = get_playlist_info(url)
if info['is_playlist']:
        await status_msg.edit_text(
            f"📋 *Playlist:* info['title']\n"
            f"🎵 *Videos:* info['count']\n"
            f"🎯 *Mode:* 'Audio' if mode == 'audio' else 'Video'\n\n"
            f"Starting download..."
        )
    else:
        await status_msg.edit_text(f"Downloading: info['title']")
# Prepare yt-dlp options
    user_folder = Path(DOWNLOAD_DIR) / str(user_id)
    user_folder.mkdir(exist_ok=True)
if mode == 'audio':
        ydl_opts = 
            'format': 'bestaudio/best',
            'postprocessors': [
                'key': 'FFmpegExtractAudio',
                'preferredcodec': 'mp3',
                'preferredquality': '192',
            ],
            'outtmpl': str(user_folder / '%(title)s.%(ext)s'),
            'quiet': True,
            'no_warnings': True,
            'extract_flat': False,
else:  # video
        ydl_opts = 
            'format': 'best[height<=720]',  # Limit to 720p to save size
            'outtmpl': str(user_folder / '%(title)s.%(ext)s'),
            'quiet': True,
            'no_warnings': True,
            'extract_flat': False,
# Download playlist
    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
        # Hook for progress updates
        def progress_hook(d):
            if d['status'] == 'downloading':
                if '_percent_str' in d:
                    percent = d.get('_percent_str', '0%').strip()
                    asyncio.create_task(
                        status_msg.edit_text(f"📥 Downloading: percent complete...")
                    )
            elif d['status'] == 'finished':
                asyncio.create_task(
                    status_msg.edit_text("✅ Download complete! Processing...")
                )
ydl.add_progress_hook(progress_hook)
        info = ydl.extract_info(url, download=True)
# Send files
    if 'entries' in info:  # Playlist
        total = len(info['entries'])
        sent = 0
        skipped = 0
for idx, entry in enumerate(info['entries'], 1):
            # Check for cancel
            if user_id in user_sessions and user_sessions[user_id].get('cancel', False):
                await update.message.reply_text("❌ Download cancelled by user.")
                break
# Find downloaded file
            video_title = entry.get('title', f'video_idx')
            for file_path in user_folder.glob('*'):
                if video_title in file_path.stem:
                    file_size_mb = get_size_mb(str(file_path))
if file_size_mb > MAX_FILE_SIZE_MB:
                        await update.message.reply_text(
                            f"⚠️ *Skipped:* video_title\n"
                            f"Size: file_size_mb:.1fMB > MAX_FILE_SIZE_MBMB limit",
                            parse_mode='Markdown'
                        )
                        skipped += 1
                        continue
# Send file
                    try:
                        with open(file_path, 'rb') as f:
                            if mode == 'audio':
                                await update.message.reply_audio(
                                    audio=f,
                                    title=video_title,
                                    performer="YouTube",
                                    caption=f"📌 sent+1/total"
                                )
                            else:
                                await update.message.reply_video(
                                    video=f,
                                    caption=f"📌 sent+1/total\n🎬 video_title"
                                )
                        sent += 1
# Progress update
                        await status_msg.edit_text(
                            f"📤 Sent: sent/total\n"
                            f"⏭️ Skipped: skipped (size limit)\n"
                            f"⏳ Progress: int((sent+skipped)/total*100)%"
                        )
                    except Exception as e:
                        await update.message.reply_text(f"❌ Failed to send video_title: str(e)[:100]")
break
await asyncio.sleep(0.5)  # Rate limiting
# Summary
        await update.message.reply_text(
            f"✅ *Download Complete!*\n"
            f"📤 Sent: sent files\n"
            f"⏭️ Skipped: skipped (size limit)\n"
            f"📊 Total processed: sent+skipped/total",
            parse_mode='Markdown'
        )
else:  # Single video
        # Find the downloaded file
        for file_path in user_folder.glob('*'):
            file_size_mb = get_size_mb(str(file_path))
if file_size_mb > MAX_FILE_SIZE_MB:
                await update.message.reply_text(
                    f"❌ File too large: file_size_mb:.1fMB > MAX_FILE_SIZE_MBMB limit"
                )
            else:
                with open(file_path, 'rb') as f:
                    if mode == 'audio':
                        await update.message.reply_audio(
                            audio=f,
                            title=info.get('title', 'Audio'),
                            performer=info.get('uploader', 'YouTube')
                        )
                    else:
                        await update.message.reply_video(
                            video=f,
                            caption=f"🎬 info.get('title', 'Video')"
                        )
                await update.message.reply_text("✅ Download complete!")
except Exception as e:
    await update.message.reply_text(f"❌ Error: str(e)[:200]")
finally:
    # Cleanup
    await delete_download_folder(user_id)
    if user_id in user_sessions:
        del user_sessions[user_id]

import os
import re
import asyncio
import shutil
from pathlib import Path
from typing import Dict
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import Application, CommandHandler, CallbackQueryHandler, MessageHandler, filters, ContextTypes
import yt_dlp
Before listing the bots, let’s understand why this method is superior.
In the digital age, video content is king, but storage space is a luxury. Whether you want to listen to a study music mix offline, archive a tutorial series, or save a vlog compilation, downloading entire YouTube playlists has become a necessity.
However, traditional methods are clunky. Dedicated software often requires installation, risks malware, or bombards you with ads. Enter the solution: the Telegram bot.
Telegram, the cloud-based messaging app, has evolved into a powerful file-sharing ecosystem. Using a specialized Telegram bot to download YouTube playlists for free is arguably the fastest, safest, and most convenient method available today. This guide will explain everything you need to know, from finding the right bot to troubleshooting common issues. Limits: • Max 50MB per file (Telegram limit)
These bots are essentially automated interfaces for youtube-dl or yt-dlp—powerful open-source command-line programs that extract videos from YouTube. When you send a playlist link to the bot, it:

Because Telegram has a file size limit (usually 2GB per file for bots), these bots are ideal for playlists of standard songs (3-5 minutes each).

pip install python-telegram-bot yt-dlp