getoutvideo 1.1.1

Extract and process YouTube video transcripts with AI

GetOutVideo API

Transform YouTube videos into professional documents with AI

GetOutVideo is a Python API that converts YouTube videos into structured, readable documents. Simply provide a YouTube URL, and it extracts transcripts and transforms them into professional-quality materials using OpenAI's GPT models.

What it does

Turn any YouTube video into:

• Summaries - Quick overviews and key points
• Educational materials - Structured lessons and tutorials
• Documentation - Technical guides and how-tos
• Study notes - Q&A format and bullet points
• Research content - Comprehensive analysis

Perfect for students, researchers, content creators, and professionals who want to convert video content into text-based learning materials.

Features

• YouTube Integration: Extract transcripts from individual videos
• AI Processing: Transform raw transcripts using OpenAI's GPT models
• Multiple Styles: Generate summaries, educational content, Q&A, key points, and more
• Flexible Configuration: Customize processing parameters, languages, and output formats
• Fallback Transcription: Uses OpenAI's audio transcription when YouTube transcripts aren't available
• Clean API: Simple interface for both basic and advanced use cases

Installation

pip install getoutvideo

System Requirements

• Python 3.8 or higher
• FFmpeg (required for audio processing fallback)

Installing FFmpeg

Windows:

# Using chocolatey
choco install ffmpeg

# Or download from https://ffmpeg.org/download.html

macOS:

# Using homebrew
brew install ffmpeg

Linux:

# Ubuntu/Debian
sudo apt update && sudo apt install ffmpeg

# CentOS/RHEL
sudo yum install ffmpeg

Quick Start

Basic Usage

from getoutvideo import process_youtube_video

# Process a single video
files = process_youtube_video(
    url="https://www.youtube.com/watch?v=7gp7GkPE-tI",
    output_dir="./output",
    openai_api_key="your-openai-api-key"
)

print(f"Generated {len(files)} documents!")
# Creates: video_title [Summary].md, video_title [Educational].md, etc.

Process Specific Styles

from getoutvideo import GetOutVideoAPI

api = GetOutVideoAPI(openai_api_key="your-openai-api-key")

# Generate only summaries and educational content
files = api.process_youtube_url(
    url="https://www.youtube.com/watch?v=VIDEO_ID",
    output_dir="./summaries",
    styles=["Summary", "Educational"]
)

How It Works

1. Extract - Downloads transcripts from YouTube (with AI fallback when needed)
2. Process - Uses OpenAI's GPT models to format and structure content
3. Generate - Creates professional markdown documents in multiple styles

Available Processing Styles

GetOutVideo creates different document types from the same video:

Style	Best For	Output Format
Summary	Quick overviews	Concise main points
Educational	Learning materials	Structured lessons with examples
Balanced and Detailed	Comprehensive reports	Full detailed coverage with all information
Q&A Generation	Training materials	Question and answer format
Narrative Rewriting	Engaging content	Story-like format while maintaining facts

# Get all available styles
from getoutvideo import GetOutVideoAPI
api = GetOutVideoAPI(openai_api_key="your-key")
print(api.get_available_styles())

Configuration

Using Environment Variables

export OPENAI_API_KEY="your-openai-api-key"
export LANGUAGE="English"

from getoutvideo import load_api_from_env
api = load_api_from_env()  # Uses environment variables

API Reference

Main Functions

process_youtube_video()

One-line processing for videos:

from getoutvideo import process_youtube_video

files = process_youtube_video(
    url="https://www.youtube.com/watch?v=VIDEO_ID",
    output_dir="./output",
    openai_api_key="your-openai-api-key",
    styles=["Summary", "Educational"],  # Optional
    output_language="English"          # Optional
)

GetOutVideoAPI Class

For advanced control:

from getoutvideo import GetOutVideoAPI

api = GetOutVideoAPI(openai_api_key="your-openai-api-key")

# Process videos
files = api.process_youtube_url(url, output_dir, styles=["Summary"])

# Extract transcripts only
transcripts = api.extract_transcripts(url)

# Process existing transcripts
results = api.process_with_ai(transcripts, output_dir, styles=["Educational"])

extract_transcripts_only()

Get raw transcripts without AI processing:

from getoutvideo import extract_transcripts_only

transcripts = extract_transcripts_only(
    url="https://www.youtube.com/watch?v=VIDEO_ID",
    openai_api_key="your-openai-api-key"
)

Use Cases

Course Materials

# Convert lectures to study materials
study_files = process_youtube_video(
    url="https://www.youtube.com/watch?v=LECTURE_VIDEO",
    output_dir="./course_materials",
    openai_api_key="your-key",
    styles=["Educational", "Summary"]
)

Technical Documentation

# Turn tutorial videos into documentation
api = GetOutVideoAPI(openai_api_key="your-key")
transcripts = api.extract_transcripts("https://www.youtube.com/watch?v=TUTORIAL_ID")
docs = api.process_with_ai(transcripts, "./docs", styles=["Educational"])

Research and Analysis

# Process conference talks for research
files = process_youtube_video(
    url="https://www.youtube.com/watch?v=CONFERENCE_TALK",
    output_dir="./research",
    openai_api_key="your-key",
    styles=["Balanced", "Summary"]
)

Output Files

Generated files follow this naming pattern:

{video_title} [{style_name}].md

Example output for "Python Tutorial":

📁 output/
├── Python_Tutorial [Summary].md
├── Python_Tutorial [Educational].md  
├── Python_Tutorial [Balanced and Detailed].md
└── Python_Tutorial [Q&A Generation].md

Each file contains:

• Original video URL
• Structured content in markdown format
• Style-specific formatting (bullets, sections, Q&A, etc.)

Error Handling

from getoutvideo import GetOutVideoAPI, GetOutVideoError

try:
    api = GetOutVideoAPI(openai_api_key="your-key")
    files = api.process_youtube_url(url="...", output_dir="./output")
    print(f"Success: {len(files)} files generated")
except GetOutVideoError as e:
    print(f"API Error: {e}")
except Exception as e:
    print(f"Error: {e}")

Rate Limits and Costs

• Respects OpenAI rate limits automatically
• Costs depend on transcript length and models used
• Use specific styles parameter to reduce processing
• Adjust chunk_size for cost optimization

Development

git clone https://github.com/yourusername/getoutvideo.git
cd getoutvideo
pip install -e ".[dev]"
pytest tests/          # Run tests
black getoutvideo/     # Format code

License

MIT License - see LICENSE file for details.

Support

• Issues: GitHub Issues
• Documentation: Full API docs and examples available

Credits

Built with OpenAI GPT models, YouTube Transcript API, and FFmpeg for audio processing.