Catatan: YouTube Content ID API ditujukan untuk digunakan oleh partner konten YouTube dan tidak dapat diakses oleh semua developer atau pengguna YouTube. Jika Anda tidak melihat YouTube Content ID API sebagai salah satu layanan yang tercantum di Konsol API Google, lihat Pusat Bantuan YouTube untuk mempelajari Program Partner YouTube lebih lanjut.
Contoh kode ini menunjukkan cara mengupload video YouTube dan menerapkan kebijakan monetisasi pada video tersebut. Untuk memonetisasi video, Anda harus mengklaim video dengan asset
di sistem pengelolaan hak YouTube. Sampel mengupload video, membuat aset baru, mengklaim video menggunakan aset tersebut, dan menerapkan kebijakan monetisasi pada video tersebut.
Contoh ini disajikan sebagai serangkaian langkah yang disertakan bersama dengan bagian kode yang relevan. Anda dapat menemukan seluruh skrip di akhir halaman ini. Kode ini ditulis di Python. Library klien untuk bahasa pemrograman populer lainnya juga tersedia.
Persyaratan
- Python 2.5 atau yang lebih baru
- google-api-python-client
Langkah 1: Fungsi umum rumah tangga
Bagian pertama contoh kode menjalankan fungsi housekeeping dasar yang umum untuk banyak skrip: mengurai baris perintah, mengautentikasi pengguna, dan mendapatkan layanan API yang diperlukan.
Mengurai command line
Metode parse_options
menggunakan OptionParser
dari library klien Python untuk membuat objek options
yang berisi setiap argumen command line sebagai properti. Metode berikutnya akan mengambil nilai dari objek options
sesuai kebutuhan.
Contoh argumen command line skrip tercantum di bawah ini. Dua kolom pertama (file
dan channelId
) wajib ada; sisanya bersifat opsional.
-
file
: Nama dan lokasi file video yang akan diupload.Example: --file="/home/path/to/file.mov"
-
channelId
: Channel YouTube tempat Anda ingin mengupload video. Channel tersebut harus dikelola oleh akun Pengelola Konten YouTube milik pengguna yang diautentikasi. Anda dapat mengambil ID channel di setelan akun YouTube untuk pengguna terautentikasi atau dengan menggunakan metodechannels.list
.Example: --channelId="UC_x5XG1OV2P6uZZ5FSM9Ttw"
-
title
: Judul untuk video yang sedang Anda upload. Nilai defaultnya adalahTest title
.Example: --title="Summer vacation in California"
-
description
: Deskripsi video yang sedang Anda upload. Nilai defaultnya adalahTest description
.Example: --description="Had a great time surfing in Santa Cruz"
-
category
: ID kategori untuk kategori video YouTube yang terkait dengan video. Nilai defaultnya adalah22
, yang mengacu pada kategoriPeople & Blogs
.Example: --category=22
-
keywords
: Daftar kata kunci yang dipisahkan koma yang terkait dengan video. Nilai defaultnya adalah string kosong.Example: --keywords="surfing, beach volleyball"
-
privacyStatus
: Status privasi video. Perilaku default adalah video yang diupload dapat dilihat oleh publik (public
). Saat mengupload video uji coba, Anda dapat menentukan nilai argumen--privacyStatus
untuk memastikan bahwa video tersebut bersifat pribadi atau tidak publik. Nilai yang valid adalahpublic
,private
, danunlisted
.Example: --privacyStatus="private"
-
policyId
: Kebijakan monetisasi yang akan diterapkan pada video yang diupload. Kebijakan ini harus dikaitkan dengan akun Pengelola Konten YouTube milik pengguna yang diautentikasi. Kebijakan default-nya adalah kebijakan "monetisasi" YouTube standar.Example: --policyId="S309961703555739"
def parse_options(): parser = OptionParser() parser.add_option("--file", dest="file", help="Video file to upload") parser.add_option("--title", dest="title", help="Video title", default="Test Title") parser.add_option("--description", dest="description", help="Video description", default="Test Description") parser.add_option("--category", dest="category", help="Numeric video category. " + "See https://developers.google.com/youtube/v3/docs/videoCategories/list", default="22") parser.add_option("--keywords", dest="keywords", help="Video keywords, comma separated", default="") parser.add_option("--privacyStatus", dest="privacyStatus", help="Video privacy status: public, private or unlisted", default="public") parser.add_option("--policyId", dest="policyId", help="Optional id of a saved claim policy") parser.add_option("--channelId", dest="channelId", help="Id of the channel to upload to. Must be managed by your CMS account") (options, args) = parser.parse_args() return options
Mengizinkan permintaan
Pada langkah ini, kami akan menerapkan otorisasi OAuth 2.0 ke dalam skrip. Hal ini memungkinkan pengguna yang menjalankan skrip untuk memberikan otorisasi pada skrip agar dapat melakukan permintaan API yang diatribusikan ke akun pengguna.
Membuat file client_secrets.json
Jenis otorisasi yang ditampilkan dalam contoh memerlukan file client_secrets.json
, yang berisi informasi dari Konsol API Google, untuk melakukan otorisasi. Anda juga harus mendaftarkan aplikasi Anda. Untuk penjelasan lebih lengkap tentang cara kerja otorisasi, lihat panduan otorisasi. Perlu diperhatikan bahwa contoh ini mengharuskan layanan YouTube Data API V3 dan YouTube Content ID API dikonfigurasi di Konsol API untuk project Anda.
{ "web": { "client_id": "INSERT CLIENT ID HERE", "client_secret": "INSERT CLIENT SECRET HERE", "redirect_uris": [], "auth_uri": "https://accounts.google.com/o/oauth2/auth", "token_uri": "https://accounts.google.com/o/oauth2/token" } }
Kode otorisasi dalam skrip
Skrip ini menyertakan pernyataan import
berikut untuk memungkinkan autentikasi dan otorisasi pengguna:
from oauth2client.file import Storage from oauth2client.client import flow_from_clientsecrets from oauth2client.tools import run
Selanjutnya, metode get_authenticated_services
membuat objek FLOW
menggunakan data dari file client_secrets.json
yang dikonfigurasi pada langkah sebelumnya. Jika pengguna mengizinkan aplikasi kita untuk mengirimkan permintaan API atas nama pengguna, kredensial yang dihasilkan akan disimpan dalam objek Storage
untuk digunakan nanti. Pengguna perlu memberikan otorisasi ulang ke aplikasi kita jika masa berlaku kredensial berakhir.
YOUTUBE_SCOPES = ( # An OAuth 2 access scope that allows for full read/write access. "https://www.googleapis.com/auth/youtube", # A scope that grants access to YouTube Partner API functionality. "https://www.googleapis.com/auth/youtubepartner") flow = flow_from_clientsecrets( CLIENT_SECRETS_FILE, scope=" ".join(YOUTUBE_SCOPES), message=MISSING_CLIENT_SECRETS_MESSAGE ) storage = Storage(CACHED_CREDENTIALS_FILE) credentials = storage.get() if credentials is None or credentials.invalid: credentials = run(flow, storage)
Mendapatkan layanan
Setelah otorisasi berhasil, kita memperoleh layanan yang diperlukan untuk operasi yang ingin kita lakukan. Sampel tersebut menggunakan YouTube Data API untuk mengupload video dan YouTube Content ID API untuk membuat aset dan mengklaim video. Kami membuat layanan terpisah untuk memberikan akses terotorisasi ke fungsi kedua API.
from googleapiclient.discovery import build import httplib2 YOUTUBE_API_SERVICE_NAME = "youtube" YOUTUBE_API_VERSION = "v3" YOUTUBE_CONTENT_ID_API_SERVICE_NAME = "youtubePartner" YOUTUBE_CONTENT_ID_API_VERSION = "v1" youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http())) youtube_partner = build(YOUTUBE_CONTENT_ID_API_SERVICE_NAME, YOUTUBE_CONTENT_ID_API_VERSION, http=credentials.authorize(httplib2.Http()), static_discovery=False) return (youtube, youtube_partner)
Langkah 2: Identifikasi pemilik konten
Untuk membuat aset dan membuat klaim, pengguna yang diautentikasi harus memiliki akun Pengelola Konten YouTube. Akun Pengelola Konten memiliki objek pengelolaan hak untuk satu atau beberapa pemilik konten. Pemilik konten adalah pemegang hak cipta yang memiliki hak untuk memutuskan apakah akan memonetisasi, melacak, atau memblokir video.
Metode get_content_owner
mengambil ID pemilik konten di akun Pengelola Konten milik pengguna yang diautentikasi. Sebagian besar akun memiliki satu pemilik konten (pengguna terautentikasi), tetapi jika akun memiliki beberapa pemilik konten, metode akan menampilkan pemilik konten pertama.
def get_content_owner_id(youtube_partner): try: content_owners_list_response = youtube_partner.contentOwners().list( fetchMine=True ).execute() except HttpError, e: if INVALID_CREDENTIALS in e.content: logging.error("The request is not authorized by a Google Account that " "is linked to a YouTube content owner. Please delete '%s' and " "re-authenticate with a YouTube content owner account." % CACHED_CREDENTIALS_FILE) exit(1) else: raise # This returns the CMS user id of the first entry returned # by youtubePartner.contentOwners.list() # See https://developers.google.com/youtube/partner/reference/rest/v1/contentOwners/list # Normally this is what you want, but if you authorize with a Google Account # that has access to multiple YouTube content owner accounts, you need to # iterate through the results. return content_owners_list_response["items"][0]["id"]
Langkah 3: Upload video
Untuk mengupload video, kita membuat resource JSON parsial yang mewakili video dan meneruskannya ke metode videos.insert
. Kita menetapkan metadata video menggunakan nilai dari objek options
yang dibuat saat mengurai command line. Untuk file media itu sendiri, kita menggunakan MediaFileUpload
agar dapat menggunakan upload yang dapat dilanjutkan. Baca cara Mengupload video untuk mengetahui detail selengkapnya.
Metode upload
menampilkan ID video untuk video baru, dan skrip harus meneruskan nilai tersebut ke metode lain di langkah berikutnya.
def upload(youtube, content_owner_id, options): if options.keywords: tags = options.keywords.split(",") else: tags = None insert_request = youtube.videos().insert( onBehalfOfContentOwner=content_owner_id, onBehalfOfContentOwnerChannel=options.channelId, part="snippet,status", body=dict( snippet=dict( title=options.title, description=options.description, tags=tags, categoryId=options.category ), status=dict( privacyStatus=options.privacyStatus ) ), # chunksize=-1 means that the entire file will be uploaded in a single # HTTP request. (If the upload fails, it will still be retried where it # left off.) This is usually a best practice, but if you're using Python # older than 2.6 or if you're running on App Engine, you should set the # chunksize to something like 1024 * 1024 (1 megabyte). media_body=MediaFileUpload(options.file, chunksize=-1, resumable=True) ) response = None error = None retry = 0 duration_seconds=0 while response is None: try: logging.debug("Uploading file...") start_seconds = time.time() status, response = insert_request.next_chunk() delta_seconds = time.time() - start_seconds duration_seconds += delta_seconds if "id" in response: return (response["id"], duration_seconds) else: logging.error("The upload failed with an unexpected response: %s" % response) exit(1) except HttpError, e: if e.resp.status in RETRIABLE_STATUS_CODES: error = "A retriable HTTP error %d occurred:\n%s" % (e.resp.status, e.content) else: raise except RETRIABLE_EXCEPTIONS, e: error = "A retriable error occurred: %s" % e if error is not None: logging.error(error) retry += 1 if retry > MAX_RETRIES: logging.error("No longer attempting to retry.") exit(1) max_sleep = 2 ** retry sleep_seconds = random.random() * max_sleep logging.debug("Sleeping %f seconds and then retrying..." % sleep_seconds) time.sleep(sleep_seconds)
Langkah 4: Buat aset
Untuk memonetisasi video YouTube, Anda harus mengaitkannya terlebih dahulu dengan aset. Metode create_asset
akan membuat aset baru untuk video yang baru diupload.
Sama seperti yang dilakukan pada video, kita membuat resource JSON parsial yang mengidentifikasi jenis aset yang akan dibuat (video web) dan memberikan judul serta deskripsi untuk aset baru tersebut. Kita meneruskan resource JSON ke metode assets.insert
, yang membuat aset dan menampilkan ID uniknya. Sekali lagi, skrip harus meneruskan nilai tersebut ke metode lain di langkah berikutnya.
def create_asset(youtube_partner, content_owner_id, title, description): # This creates a new asset corresponding to a video on the web. # The asset is linked to the corresponding YouTube video via a # claim that will be created later. body = dict( type="web", metadata=dict( title=title, description=description ) ) assets_insert_response = youtube_partner.assets().insert( onBehalfOfContentOwner=content_owner_id, body=body ).execute() return assets_insert_response["id"]
Langkah 5: Perbarui kepemilikan
Sebelum dapat memonetisasi video, YouTube harus mengetahui pemilik aset terkait. Jadi, setelah aset dibuat, sekarang kita akan mengonfigurasi ownership
aset. Dalam contoh ini, kami menyebutkan bahwa pemilik konten memiliki aset di seluruh dunia.
def set_asset_ownership(youtube_partner, content_owner_id, asset_id): # This specifies that content_owner_id owns 100% of the asset worldwide. # Adjust as needed. body = dict( general=[dict( owner=content_owner_id, ratio=100, type="exclude", territories=[] )] ) youtube_partner.ownership().update( onBehalfOfContentOwner=content_owner_id, assetId=asset_id, body=body ).execute()
Langkah 6: Klaim video
Langkah selanjutnya adalah mengaitkan video yang diupload dengan asetnya yang sesuai dengan mengklaim video tersebut. Klaim tersebut menghubungkan video dengan sistem pengelolaan hak YouTube, yang menetapkan kepemilikan video dan memungkinkan pemiliknya untuk menetapkan kebijakan monetisasi.
Metode claim_video
mengklaim hak audiovisual. Jika Anda menyertakan parameter policyId
di command line, metode tersebut akan menerapkan kebijakan yang ditentukan pada video; jika Anda tidak menyertakan parameter tersebut, metode tersebut akan menerapkan kebijakan "monetisasi" standar.
def claim_video(youtube_partner, content_owner_id, asset_id, video_id, policy_id): # policy_id can be set to the id of an existing policy, which can be obtained # via youtubePartner.policies.list() # See https://developers.google.com/youtube/partner/reference/rest/v1/policies/list # If you later update that existing policy, the claim will also be updated. if policy_id: policy = dict( id=policy_id ) # If policy_id is not provided, a new inline policy is created. else: policy = dict( rules=[dict( action="monetize" )] ) body = dict( assetId=asset_id, videoId=video_id, policy=policy, contentType="audiovisual" ) youtube_partner.claims().insert( onBehalfOfContentOwner=content_owner_id, body=body ).execute()
Langkah 7: Tetapkan opsi iklan
Kami telah mengklaim video tersebut dan menerapkan kebijakan monetisasi pada video tersebut. Langkah terakhir adalah menentukan jenis iklan yang akan ditampilkan dalam video. Setiap kali kebijakan "monetisasi" berlaku, YouTube akan memeriksa opsi iklan dan menampilkan jenis iklan dengan pendapatan tertinggi yang tersedia.
Contoh ini memberi tahu YouTube untuk menampilkan iklan TrueView in-stream dengan video ini.
def set_advertising_options(youtube_partner, content_owner_id, video_id): # This enables the TrueView ad format for the given video. # Adjust as needed. body = dict( adFormats=["trueview_instream"] ) youtube_partner.videoAdvertisingOptions().update( videoId=video_id, onBehalfOfContentOwner=content_owner_id, body=body ).execute()
Contoh kode lengkap
Contoh lengkap upload_monetize_video_example.py
yang berfungsi tercantum di bawah ini:
#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (C) 2013 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Simple command-line sample for Youtube Partner API. Command-line application that creates an asset, uploads and claims a video for that asset. Usage: $ python upload_monetize_video_example.py --file=VIDEO_FILE --channelID=CHANNEL_ID \ [--title=VIDEO_TITLE] [--description=VIDEO_DESCRIPTION] [--category=CATEGORY_ID] \ [--keywords=KEYWORDS] [--privacyStatus=PRIVACY_STATUS] [--policyId=POLICY_ID] You can also get help on all the command-line flags the program understands by running: $ python upload_monetize_video_example.py --help """ __author__ = 'jeffy+pub@google.com (Jeffrey Posnick)' import httplib import httplib2 import logging import os import random import sys import time from apiclient.discovery import build from apiclient.errors import HttpError from apiclient.http import MediaFileUpload from oauth2client.file import Storage from oauth2client.client import flow_from_clientsecrets from oauth2client.tools import run from optparse import OptionParser # Explicitly tell the underlying HTTP transport library not to retry, since # we are handling retry logic ourselves. httplib2.RETRIES = 1 # Maximum number of times to retry before giving up. MAX_RETRIES = 10 # Always retry when these exceptions are raised. RETRIABLE_EXCEPTIONS = (httplib2.HttpLib2Error, IOError, httplib.NotConnected, httplib.IncompleteRead, httplib.ImproperConnectionState, httplib.CannotSendRequest, httplib.CannotSendHeader, httplib.ResponseNotReady, httplib.BadStatusLine,) # Always retry when an apiclient.errors.HttpError with one of these status # codes is raised. RETRIABLE_STATUS_CODES = (500, 502, 503, 504,) # The message associated with the HTTP 401 error that's returned when a request # is authorized by a user whose account is not associated with a YouTube # content owner. INVALID_CREDENTIALS = "Invalid Credentials" # The CLIENT_SECRETS_FILE variable specifies the name of a file that contains # the OAuth 2.0 information for this application, including its client_id and # client_secret. You can acquire an OAuth 2.0 client ID and client secret from # the Google API Console at # https://console.cloud.google.com/. # See the "Registering your application" instructions for an explanation # of how to find these values: # https://developers.google.com/youtube/partner/guides/registering_an_application # For more information about using OAuth2 to access Google APIs, please visit: # https://developers.google.com/accounts/docs/OAuth2 # For more information about the client_secrets.json file format, please visit: # https://developers.google.com/api-client-library/python/guide/aaa_client_secrets CLIENT_SECRETS_FILE = "client_secrets.json" # The local file used to store the cached OAuth 2 credentials after going # through a one-time browser-based login. CACHED_CREDENTIALS_FILE = "%s-oauth2.json" % sys.argv[0] YOUTUBE_SCOPES = ( # An OAuth 2 access scope that allows for full read/write access. "https://www.googleapis.com/auth/youtube", # A scope that grants access to YouTube Partner API functionality. "https://www.googleapis.com/auth/youtubepartner",) YOUTUBE_API_SERVICE_NAME = "youtube" YOUTUBE_API_VERSION = "v3" YOUTUBE_CONTENT_ID_API_SERVICE_NAME = "youtubePartner" YOUTUBE_CONTENT_ID_API_VERSION = "v1" # Helpful message to display if the CLIENT_SECRETS_FILE is missing. MISSING_CLIENT_SECRETS_MESSAGE = """ WARNING: Please configure OAuth 2.0 To make this sample run you need to populate the client_secrets.json file at: %s with information from the API Console https://console.cloud.google.com/ For more information about the client_secrets.json file format, please visit: https://developers.google.com/api-client-library/python/guide/aaa_client_secrets """ % os.path.abspath(os.path.join(os.path.dirname(__file__), CLIENT_SECRETS_FILE)) def parse_options(): parser = OptionParser() parser.add_option("--file", dest="file", help="Video file to upload") parser.add_option("--title", dest="title", help="Video title", default="Test Title") parser.add_option("--description", dest="description", help="Video description", default="Test Description") parser.add_option("--category", dest="category", help="Numeric video category. " + "See https://developers.google.com/youtube/v3/docs/videoCategories/list", default="22") parser.add_option("--keywords", dest="keywords", help="Video keywords, comma separated", default="") parser.add_option("--privacyStatus", dest="privacyStatus", help="Video privacy status: public, private or unlisted", default="public") parser.add_option("--policyId", dest="policyId", help="Optional id of a saved claim policy") parser.add_option("--channelId", dest="channelId", help="Id of the channel to upload to. Must be managed by your CMS account") (options, args) = parser.parse_args() return options def get_authenticated_services(): flow = flow_from_clientsecrets( CLIENT_SECRETS_FILE, scope=" ".join(YOUTUBE_SCOPES), message=MISSING_CLIENT_SECRETS_MESSAGE ) storage = Storage(CACHED_CREDENTIALS_FILE) credentials = storage.get() if credentials is None or credentials.invalid: credentials = run(flow, storage) youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http())) youtube_partner = build(YOUTUBE_CONTENT_ID_API_SERVICE_NAME, YOUTUBE_CONTENT_ID_API_VERSION, http=credentials.authorize(httplib2.Http()), static_discovery=False) return (youtube, youtube_partner) def get_content_owner_id(youtube_partner): try: content_owners_list_response = youtube_partner.contentOwners().list( fetchMine=True ).execute() except HttpError, e: if INVALID_CREDENTIALS in e.content: logging.error("Your request is not authorized by a Google Account that " "is associated with a YouTube content owner. Please delete '%s' and " "re-authenticate with an account that is associated " "with a content owner." % CACHED_CREDENTIALS_FILE) exit(1) else: raise # This returns the CMS user id of the first entry returned # by youtubePartner.contentOwners.list() # See https://developers.google.com/youtube/partner/reference/rest/v1/contentOwners/list # Normally this is what you want, but if you authorize with a Google Account # that has access to multiple YouTube content owner accounts, you need to # iterate through the results. return content_owners_list_response["items"][0]["id"] def upload(youtube, content_owner_id, options): if options.keywords: tags = options.keywords.split(",") else: tags = None insert_request = youtube.videos().insert( onBehalfOfContentOwner=content_owner_id, onBehalfOfContentOwnerChannel=options.channelId, part="snippet,status", body=dict( snippet=dict( title=options.title, description=options.description, tags=tags, categoryId=options.category ), status=dict( privacyStatus=options.privacyStatus ) ), # chunksize=-1 means that the entire file will be uploaded in a single # HTTP request. (If the upload fails, it will still be retried where it # left off.) This is usually a best practice, but if you're using Python # older than 2.6 or if you're running on App Engine, you should set the # chunksize to something like 1024 * 1024 (1 megabyte). media_body=MediaFileUpload(options.file, chunksize=-1, resumable=True) ) response = None error = None retry = 0 duration_seconds=0 while response is None: try: logging.debug("Uploading file...") start_seconds = time.time() status, response = insert_request.next_chunk() delta_seconds = time.time() - start_seconds duration_seconds += delta_seconds if "id" in response: return (response["id"], duration_seconds) else: logging.error("The upload failed with an unexpected response: %s" % response) exit(1) except HttpError, e: if e.resp.status in RETRIABLE_STATUS_CODES: error = "A retriable HTTP error %d occurred:\n%s" % (e.resp.status, e.content) else: raise except RETRIABLE_EXCEPTIONS, e: error = "A retriable error occurred: %s" % e if error is not None: logging.error(error) retry += 1 if retry > MAX_RETRIES: logging.error("No longer attempting to retry.") exit(1) max_sleep = 2 ** retry sleep_seconds = random.random() * max_sleep logging.debug("Sleeping %f seconds and then retrying..." % sleep_seconds) time.sleep(sleep_seconds) def create_asset(youtube_partner, content_owner_id, title, description): # This creates a new asset corresponding to a video on the web. # The asset is linked to the corresponding YouTube video via a # claim that will be created later. body = dict( type="web", metadata=dict( title=title, description=description ) ) assets_insert_response = youtube_partner.assets().insert( onBehalfOfContentOwner=content_owner_id, body=body ).execute() return assets_insert_response["id"] def set_asset_ownership(youtube_partner, content_owner_id, asset_id): # This specifies that content_owner_id owns 100% of the asset worldwide. # Adjust as needed. body = dict( general=[dict( owner=content_owner_id, ratio=100, type="exclude", territories=[] )] ) youtube_partner.ownership().update( onBehalfOfContentOwner=content_owner_id, assetId=asset_id, body=body ).execute() def claim_video(youtube_partner, content_owner_id, asset_id, video_id, policy_id): # policy_id can be set to the id of an existing policy, which can be obtained # via youtubePartner.policies.list() # See https://developers.google.com/youtube/partner/reference/rest/v1/policies/list # If you later update that existing policy, the claim will also be updated. if policy_id: policy = dict( id=policy_id ) # If policy_id is not provided, a new inline policy is created. else: policy = dict( rules=[dict( action="monetize" )] ) body = dict( assetId=asset_id, videoId=video_id, policy=policy, contentType="audiovisual" ) claims_insert_response = youtube_partner.claims().insert( onBehalfOfContentOwner=content_owner_id, body=body ).execute() return claims_insert_response["id"] def set_advertising_options(youtube_partner, content_owner_id, video_id): # This enables the true view ad format for the given video. # Adjust as needed. body = dict( adFormats=["trueview_instream"] ) youtube_partner.videoAdvertisingOptions().update( videoId=video_id, onBehalfOfContentOwner=content_owner_id, body=body ).execute() if __name__ == '__main__': logging.basicConfig( level=logging.DEBUG, format="%(asctime)s [%(name)s] %(levelname)s: %(message)s", datefmt="%Y-%m-%d %H:%M:%S" ) options = parse_options() if options.file is None or not os.path.exists(options.file): logging.error("Please specify a valid file using the --file= parameter.") exit(1) # The channel ID looks something like "UC..." and needs to correspond to a # channel managed by the YouTube content owner authorizing the request. # youtube.channels.list(part="snippet", managedByMe=true, # onBehalfOfContentOwner=*CONTENT_OWNER_ID*) # can be used to retrieve a list of managed channels and their channel IDs. # See https://developers.google.com/youtube/v3/docs/channels/list if options.channelId is None: logging.error("Please specify a channel ID via the --channelId= parameter.") exit(1) (youtube, youtube_partner) = get_authenticated_services() content_owner_id = get_content_owner_id(youtube_partner) logging.info("Authorized by content owner ID '%s'." % content_owner_id) (video_id, duration_seconds) = upload(youtube, content_owner_id, options) logging.info("Successfully uploaded video ID '%s'." % video_id) file_size_bytes = os.path.getsize(options.file) logging.debug("Uploaded %d bytes in %0.2f seconds (%0.2f megabytes/second)." % (file_size_bytes, duration_seconds, (file_size_bytes / (1024 * 1024)) / duration_seconds)) asset_id = create_asset(youtube_partner, content_owner_id, options.title, options.description) logging.info("Created new asset ID '%s'." % asset_id) set_asset_ownership(youtube_partner, content_owner_id, asset_id) logging.info("Successfully set asset ownership.") claim_id = claim_video(youtube_partner, content_owner_id, asset_id, video_id, options.policyId) logging.info("Successfully claimed video.") set_advertising_options(youtube_partner, content_owner_id, video_id) logging.info("Successfully set advertising options.") logging.info("All done!")