API Integration October 23, 2020

YouTube Partner API with Monetization

Automating YouTube uploads with monetization for mass publishing media houses. Learn how to build a scalable video publishing system using YouTube Partner API.

YouTube Partner API

Project Context: This project was built to automate video publishing for mass media houses, enabling them to upload hundreds of videos daily with proper monetization settings, targeted advertisements, and consistent metadata across all uploads.

Overview

The YouTube Data API v3 is a powerful tool that allows developers to programmatically interact with YouTube. In this project, I built a comprehensive automation system using the YouTube Partner API to handle bulk video uploads with advanced monetization features for media publishing companies.

Traditional manual uploads are time-consuming and error-prone when dealing with hundreds of videos. This solution automates the entire workflow - from video preparation to upload, metadata management, and monetization configuration.

100+
Videos Daily
95%
Time Saved
5+
Media Houses

Key Features

1. Automated Video Upload

The system handles the complete upload process including:

2. Monetization Configuration

One of the most critical features is the ability to automatically configure monetization settings:

3. Metadata Management

Comprehensive metadata configuration for better discoverability:

4. Targeted Advertisement Scripts

Advanced features for content-specific advertising:

Technical Architecture

Authentication & Authorization

The system uses OAuth 2.0 for secure authentication with YouTube: 

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

# Define scopes for YouTube Partner API
SCOPES = [
    'https://www.googleapis.com/auth/youtube.upload',
    'https://www.googleapis.com/auth/youtube',
    'https://www.googleapis.com/auth/youtube.force-ssl',
    'https://www.googleapis.com/auth/youtubepartner'
]

def get_authenticated_service():
    flow = InstalledAppFlow.from_client_secrets_file(
        'client_secrets.json', SCOPES)
    credentials = flow.run_local_server(port=8080)
    return build('youtube', 'v3', credentials=credentials)

Video Upload Function

The core upload function with monetization settings: 

def upload_video_with_monetization(youtube, video_file, metadata):
    body = {
        'snippet': {
            'title': metadata['title'],
            'description': metadata['description'],
            'tags': metadata['tags'],
            'categoryId': metadata['category_id']
        },
        'status': {
            'privacyStatus': metadata['privacy_status'],
            'selfDeclaredMadeForKids': False
        },
        'monetizationDetails': {
            'access': {
                'allowed': True,
                'exception': []
            }
        }
    }
    
    media = MediaFileUpload(
        video_file,
        chunksize=1024*1024,  # 1MB chunks
        resumable=True
    )
    
    request = youtube.videos().insert(
        part='snippet,status,monetizationDetails',
        body=body,
        media_body=media
    )
    
    response = None
    while response is None:
        status, response = request.next_chunk()
        if status:
            print(f"Upload {int(status.progress() * 100)}% complete")
    
    return response

Monetization Settings Configuration

After upload, configure detailed monetization settings: 

def configure_monetization(youtube, video_id, ad_settings):
    """Configure detailed monetization settings for uploaded video"""
    
    monetization_body = {
        'id': video_id,
        'monetizationDetails': {
            'access': {
                'allowed': True,
                'exception': []
            }
        },
        'contentDetails': {
            'projection': 'rectangular',
            'hasCustomThumbnail': True
        }
    }
    
    # Set ad formats
    ad_formats = {
        'adFormats': {
            'displayAds': ad_settings.get('display_ads', True),
            'overlayAds': ad_settings.get('overlay_ads', True),
            'skippableVideoAds': ad_settings.get('skippable_ads', True),
            'nonSkippableVideoAds': ad_settings.get('non_skippable_ads', False)
        },
        'adBreaks': generate_ad_breaks(video_duration)
    }
    
    # Update video with monetization settings
    response = youtube.videos().update(
        part='monetizationDetails,contentDetails',
        body=monetization_body
    ).execute()
    
    return response

Workflow Implementation

1. Video Preparation

2. Upload Process

3. Post-Upload Configuration

4. Monitoring & Reporting

Advanced Features

Smart Ad Placement

The system analyzes video content to determine optimal ad placement: 

def generate_ad_breaks(video_duration_seconds):
    """Generate optimal ad break positions based on video length"""
    
    ad_breaks = []
    
    # Always add pre-roll
    ad_breaks.append({'position': 0, 'type': 'preRoll'})
    
    # Add mid-rolls for longer videos
    if video_duration_seconds > 480:  # 8 minutes
        # Place mid-roll every 5 minutes
        for i in range(300, video_duration_seconds - 60, 300):
            ad_breaks.append({
                'position': i,
                'type': 'midRoll'
            })
    
    # Add post-roll
    ad_breaks.append({
        'position': video_duration_seconds,
        'type': 'postRoll'
    })
    
    return ad_breaks

Batch Processing System

Handle multiple video uploads efficiently: 

import queue
import threading
from concurrent.futures import ThreadPoolExecutor

class VideoUploadQueue:
    def __init__(self, max_workers=3):
        self.queue = queue.Queue()
        self.executor = ThreadPoolExecutor(max_workers=max_workers)
        self.results = []
    
    def add_video(self, video_path, metadata):
        """Add video to upload queue"""
        self.queue.put((video_path, metadata))
    
    def process_queue(self, youtube_service):
        """Process all videos in queue"""
        futures = []
        
        while not self.queue.empty():
            video_path, metadata = self.queue.get()
            future = self.executor.submit(
                upload_video_with_monetization,
                youtube_service,
                video_path,
                metadata
            )
            futures.append(future)
        
        # Wait for all uploads to complete
        for future in futures:
            result = future.result()
            self.results.append(result)
        
        return self.results

Results & Impact

Business Impact:

  • Reduced manual upload time from 10 minutes per video to less than 30 seconds
  • Enabled media houses to scale from 10 videos/day to 100+ videos/day
  • Increased revenue through optimized ad placements and monetization settings
  • Eliminated human errors in metadata and monetization configuration
  • Provided detailed analytics and reporting for upload operations

Challenges & Solutions

API Rate Limits

Challenge: YouTube API has quota limits that could impact bulk uploads.

Solution: Implemented intelligent rate limiting with exponential backoff and request queuing to stay within quota limits while maximizing throughput.

Large File Uploads

Challenge: Network issues could interrupt uploads of large video files.

Solution: Used resumable upload protocol with automatic retry logic and checkpoint system to resume failed uploads from the last successful chunk.

Content Categorization

Challenge: Manually categorizing hundreds of videos was time-consuming.

Solution: Implemented content analysis using video metadata and filename patterns to automatically suggest appropriate categories and tags.

Key Learnings

Technologies Used

Future Enhancements

🚀 View the Code

Check out the complete source code and implementation details on GitHub

View on GitHub

Also read the detailed article on ArrayOfCode.com

Conclusion

Building this YouTube Partner API automation system taught me valuable lessons about API integration, error handling, and building scalable solutions. The project successfully automated video publishing for multiple media houses, saving hundreds of hours of manual work and enabling them to scale their content production significantly.

The combination of robust error handling, intelligent rate limiting, and comprehensive monetization configuration makes this system a powerful tool for anyone looking to automate YouTube video uploads at scale.

If you're working on a similar project or have questions about implementing YouTube API integration, feel free to reach out or check out the source code on GitHub!