YouTube Transcript API 2026: Free Python Library (No API Key Required)

pip install youtube-transcript-api

from youtube_transcript_api import YouTubeTranscriptApi

# Get transcript for a video
video_id = "dQw4w9WgXcQ"
transcript = YouTubeTranscriptApi.get_transcript(video_id)

# Print each segment
for segment in transcript:
    print(f"[{segment['start']:.2f}] {segment['text']}")

[
    {'text': 'Hey there', 'start': 0.0, 'duration': 1.5},
    {'text': 'welcome to the video', 'start': 1.5, 'duration': 2.0},
    {'text': 'today we are going to', 'start': 3.5, 'duration': 2.5},
    # ... more segments
]

from youtube_transcript_api import YouTubeTranscriptApi

# Get Spanish transcript
transcript_es = YouTubeTranscriptApi.get_transcript(
    video_id,
    languages=['es']
)

# Try multiple languages (falls back)
transcript = YouTubeTranscriptApi.get_transcript(
    video_id,
    languages=['en', 'en-US', 'en-GB']
)

from youtube_transcript_api import YouTubeTranscriptApi

transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)

for transcript in transcript_list:
    print(f"Language: {transcript.language}")
    print(f"Language code: {transcript.language_code}")
    print(f"Is generated: {transcript.is_generated}")
    print(f"Is translatable: {transcript.is_translatable}")
    print("---")

# Get English transcript and translate to Spanish
transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
transcript = transcript_list.find_transcript(['en'])
translated = transcript.translate('es')
text = translated.fetch()

from youtube_transcript_api import YouTubeTranscriptApi
from youtube_transcript_api.formatters import (
    TextFormatter,
    SRTFormatter,
    JSONFormatter
)

transcript = YouTubeTranscriptApi.get_transcript(video_id)

# Plain text
text_formatter = TextFormatter()
text_output = text_formatter.format_transcript(transcript)

# SRT format (for subtitles)
srt_formatter = SRTFormatter()
srt_output = srt_formatter.format_transcript(transcript)

# JSON format
json_formatter = JSONFormatter()
json_output = json_formatter.format_transcript(transcript)

from youtube_transcript_api import YouTubeTranscriptApi
from youtube_transcript_api._errors import (
    TranscriptsDisabled,
    NoTranscriptFound,
    VideoUnavailable
)

try:
    transcript = YouTubeTranscriptApi.get_transcript(video_id)
except TranscriptsDisabled:
    print("Transcripts are disabled for this video")
except NoTranscriptFound:
    print("No transcript found for requested language")
except VideoUnavailable:
    print("Video is unavailable (private, deleted, etc.)")
except Exception as e:
    print(f"An error occurred: {e}")

from youtube_transcript_api import YouTubeTranscriptApi

video_ids = ["video1_id", "video2_id", "video3_id"]

transcripts = YouTubeTranscriptApi.get_transcripts(
    video_ids,
    languages=['en']
)

# transcripts is a dict: {video_id: transcript_data}
for video_id, transcript in transcripts[0].items():
    print(f"Video: {video_id}")
    print(f"Segments: {len(transcript)}")

pip install google-api-python-client google-auth-oauthlib

from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow

SCOPES = ['https://www.googleapis.com/auth/youtube.force-ssl']

# Authenticate
flow = InstalledAppFlow.from_client_secrets_file(
    'client_secret.json', SCOPES
)
credentials = flow.run_local_server()

# Build API client
youtube = build('youtube', 'v3', credentials=credentials)

# List captions
request = youtube.captions().list(
    part="snippet",
    videoId="VIDEO_ID"
)
response = request.execute()

for caption in response['items']:
    print(f"Track: {caption['snippet']['name']}")
    print(f"Language: {caption['snippet']['language']}")
    print(f"ID: {caption['id']}")

# Download specific caption track
request = youtube.captions().download(
    id="CAPTION_TRACK_ID",
    tfmt="srt"  # or "sbv", "vtt"
)
caption_content = request.execute()

# pip
pip install yt-dlp

# Homebrew (Mac)
brew install yt-dlp

# Chocolatey (Windows)
choco install yt-dlp

# Download auto-generated English subtitles
yt-dlp --write-auto-sub --sub-lang en --skip-download "VIDEO_URL"

# Download manual subtitles
yt-dlp --write-sub --sub-lang en --skip-download "VIDEO_URL"

# Convert to SRT format
yt-dlp --write-auto-sub --convert-subs srt --skip-download "VIDEO_URL"

# Download all available subtitles
yt-dlp --all-subs --skip-download "VIDEO_URL"

import yt_dlp

def get_subtitles(video_url):
    ydl_opts = {
        'writeautomaticsub': True,
        'writesubtitles': True,
        'subtitleslangs': ['en'],
        'skip_download': True,
        'outtmpl': '%(id)s',
    }
    
    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
        info = ydl.extract_info(video_url, download=False)
        
        # Get subtitle data
        subtitles = info.get('subtitles', {})
        auto_captions = info.get('automatic_captions', {})
        
        return {
            'manual': subtitles,
            'auto': auto_captions,
            'title': info.get('title'),
            'duration': info.get('duration')
        }

# Usage
result = get_subtitles("https://youtube.com/watch?v=VIDEO_ID")
print(result)

from fastapi import FastAPI, HTTPException
from youtube_transcript_api import YouTubeTranscriptApi
from youtube_transcript_api._errors import (
    TranscriptsDisabled,
    NoTranscriptFound
)

app = FastAPI()

@app.get("/transcript/{video_id}")
async def get_transcript(video_id: str, lang: str = "en"):
    try:
        transcript = YouTubeTranscriptApi.get_transcript(
            video_id,
            languages=[lang, 'en']
        )
        return {
            "video_id": video_id,
            "language": lang,
            "segments": transcript,
            "text": " ".join([s['text'] for s in transcript])
        }
    except TranscriptsDisabled:
        raise HTTPException(404, "Transcripts disabled for this video")
    except NoTranscriptFound:
        raise HTTPException(404, "No transcript found")
    except Exception as e:
        raise HTTPException(500, str(e))

@app.get("/transcript/{video_id}/languages")
async def list_languages(video_id: str):
    try:
        transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
        languages = []
        for t in transcript_list:
            languages.append({
                "code": t.language_code,
                "name": t.language,
                "is_generated": t.is_generated,
                "is_translatable": t.is_translatable
            })
        return {"video_id": video_id, "languages": languages}
    except Exception as e:
        raise HTTPException(500, str(e))

pip install fastapi uvicorn
uvicorn main:app --reload

import time
from youtube_transcript_api import YouTubeTranscriptApi

video_ids = ["id1", "id2", "id3", ...]

transcripts = []
for video_id in video_ids:
    try:
        transcript = YouTubeTranscriptApi.get_transcript(video_id)
        transcripts.append((video_id, transcript))
    except Exception as e:
        print(f"Error for {video_id}: {e}")
    
    time.sleep(1)  # 1 second delay between requests

import logging
from tenacity import retry, stop_after_attempt, wait_exponential

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=2, max=10)
)
def get_transcript_with_retry(video_id):
    """Get transcript with automatic retry on failure."""
    try:
        return YouTubeTranscriptApi.get_transcript(video_id)
    except Exception as e:
        logger.warning(f"Attempt failed for {video_id}: {e}")
        raise

# Usage
try:
    transcript = get_transcript_with_retry("VIDEO_ID")
except Exception as e:
    logger.error(f"All attempts failed: {e}")

pip install youtube-transcript-api

from youtube_transcript_api import YouTubeTranscriptApi
transcript = YouTubeTranscriptApi.get_transcript("VIDEO_ID")