Remarque:L'API YouTube Content ID est destinée aux partenaires de contenu YouTube. Elle n'est pas accessible à tous les développeurs ni à tous les utilisateurs YouTube. Si l'API YouTube Content ID n'apparaît pas dans la console Google APIs, consultez le Centre d'aide YouTube pour en savoir plus sur le Programme Partenaire YouTube.
Cet exemple de code montre comment mettre en ligne une vidéo YouTube et y appliquer des règles de monétisation. Pour monétiser une vidéo, vous devez la revendiquer avec un asset
dans le système de gestion des droits de YouTube. L'exemple met en ligne la vidéo, crée un élément, revendique la vidéo à l'aide de cet élément et applique une règle de monétisation à la vidéo.
Cet exemple est présenté comme la série d'étapes impliquées, ainsi que les sections pertinentes du code. Le script complet se trouve au bas de cette page. Le code est écrit en Python. Des bibliothèques clientes sont également disponibles pour d'autres langages de programmation courants.
Conditions requises
- Python 2.5 ou version ultérieure
- google-api-python-client
Étape 1: Fonctions courantes d'entretien
Les premières sections de l'exemple de code effectuent des fonctions courantes de base, communes à de nombreux scripts: analyser la ligne de commande, authentifier l'utilisateur et obtenir les services d'API nécessaires.
Analyser la ligne de commande
La méthode parse_options
utilise OptionParser
de la bibliothèque cliente Python pour créer un objet options
contenant chaque argument de ligne de commande en tant que propriété. Les méthodes suivantes récupèrent les valeurs de l'objet options
si nécessaire.
Les arguments de ligne de commande de l'exemple de script sont listés ci-dessous. Les deux premières (file
et channelId
) sont obligatoires, les autres sont facultatives.
-
file
: nom et emplacement du fichier vidéo à mettre en ligneExample: --file="/home/path/to/file.mov"
-
channelId
: chaîne YouTube sur laquelle vous souhaitez mettre en ligne la vidéo. La chaîne doit être gérée par le compte de Gestionnaire de contenu YouTube de l'utilisateur authentifié. Vous pouvez récupérer l'ID de la chaîne dans les paramètres du compte YouTube de l'utilisateur authentifié ou en utilisant la méthodechannels.list
.Example: --channelId="UC_x5XG1OV2P6uZZ5FSM9Ttw"
-
title
: titre de la vidéo que vous mettez en ligne. La valeur par défaut estTest title
.Example: --title="Summer vacation in California"
-
description
: description de la vidéo que vous mettez en ligne. La valeur par défaut estTest description
.Example: --description="Had a great time surfing in Santa Cruz"
-
category
: ID de la catégorie de la vidéo YouTube associée à la vidéo. La valeur par défaut est22
, ce qui fait référence à la catégoriePeople & Blogs
.Example: --category=22
-
keywords
: liste de mots clés associés à la vidéo, séparés par une virgule. La valeur par défaut est une chaîne vide.Example: --keywords="surfing, beach volleyball"
-
privacyStatus
: état de confidentialité de la vidéo. Par défaut, une vidéo mise en ligne est visible publiquement (public
). Lorsque vous mettez en ligne des vidéos tests, vous pouvez spécifier une valeur d'argument--privacyStatus
pour vous assurer qu'elles sont privées ou non répertoriées. Les valeurs valides sontpublic
,private
etunlisted
.Example: --privacyStatus="private"
-
policyId
: règle de monétisation à appliquer à la vidéo mise en ligne. Les règles doivent être associées au compte de Gestionnaire de contenu YouTube de l'utilisateur authentifié. La règle de monétisation standard de YouTube est définie par défaut.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
Autoriser la requête
À cette étape, nous incorporons l'autorisation OAuth 2.0 dans le script. Ainsi, l'utilisateur qui exécute le script pourra l'autoriser à exécuter les requêtes API attribuées au compte de l'utilisateur.
Créer un fichier client_secrets.json
Le type d'autorisation indiqué dans l'exemple nécessite un fichier client_secrets.json
, qui contient des informations de la console Google APIs, pour effectuer l'autorisation. Vous devez également enregistrer votre application. Pour une explication plus complète du fonctionnement de l'autorisation, consultez le guide relatif aux autorisations. Notez que cet exemple nécessite la configuration de la version 3 de l'API YouTube Data et du service d'API YouTube Content ID dans la console API de votre projet.
{ "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" } }
Code d'autorisation dans le script
Le script inclut les instructions import
suivantes pour activer l'authentification et l'autorisation des utilisateurs:
from oauth2client.file import Storage from oauth2client.client import flow_from_clientsecrets from oauth2client.tools import run
Ensuite, la méthode get_authenticated_services
crée un objet FLOW
à l'aide des données du fichier client_secrets.json
configuré à l'étape précédente. Si l'utilisateur autorise notre application à envoyer des requêtes API en son nom, les identifiants obtenus sont stockés dans un objet Storage
pour une utilisation ultérieure. Si les identifiants expirent, l'utilisateur doit à nouveau autoriser notre application.
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)
Obtenir des services
Une fois l'autorisation obtenue, nous obtenons les services nécessaires pour les opérations que nous voulons effectuer. L'exemple utilise l'API YouTube Data pour importer la vidéo, et l'API YouTube Content ID pour créer l'élément et revendiquer la vidéo. Nous créons des services distincts pour fournir un accès autorisé aux fonctionnalités des deux 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)
Étape 2: Identifiez le propriétaire du contenu
Pour créer des éléments et effectuer des revendications, l'utilisateur authentifié doit disposer d'un compte de Gestionnaire de contenu YouTube. Le compte de Gestionnaire de contenu contient les objets de gestion des droits d'un ou plusieurs propriétaires de contenu. Le propriétaire du contenu est le titulaire des droits d'auteur qui a le droit de décider s'il souhaite monétiser, suivre ou bloquer une vidéo.
La méthode get_content_owner
récupère l'ID du propriétaire de contenu dans le compte de Gestionnaire de contenu de l'utilisateur authentifié. La plupart des comptes n'ont qu'un seul propriétaire de contenu (l'utilisateur authentifié). Toutefois, si le compte en compte plusieurs, la méthode renvoie le premier.
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"]
Étape 3: Mettez en ligne la vidéo
Pour importer une vidéo, nous créons une ressource JSON partielle représentant la vidéo et la transmettons à la méthode videos.insert
. Nous définissons les métadonnées de la vidéo à l'aide des valeurs de l'objet options
créé lors de l'analyse de la ligne de commande. Pour le fichier multimédia lui-même, nous utilisons MediaFileUpload
afin de pouvoir utiliser l'importation avec reprise. Pour en savoir plus, consultez l'article Mettre en ligne une vidéo.
La méthode upload
renvoie l'ID vidéo de la nouvelle vidéo. Le script devra transmettre cette valeur à d'autres méthodes plus tard.
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)
Étape 4: Créez un asset
Pour monétiser une vidéo YouTube, vous devez d'abord l'associer à un élément. La méthode create_asset
crée un asset pour la vidéo que vous venez de mettre en ligne.
Comme nous l'avons fait pour la vidéo, nous créons une ressource JSON partielle qui identifie le type d'élément à créer (une vidéo Web), et fournit un titre et une description pour le nouvel élément. Nous transmettons la ressource JSON à la méthode assets.insert
, qui crée l'élément et renvoie son identifiant unique. Là encore, le script doit transmettre cette valeur à d'autres méthodes dans les étapes suivantes.
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"]
Étape 5: Modifiez la propriété
Pour que vous puissiez monétiser une vidéo, YouTube doit savoir qui est le propriétaire de l'élément associé. Une fois l'asset créé, nous allons maintenant configurer son ownership
. Dans l'exemple, nous indiquons que le propriétaire de contenu est le propriétaire de l'élément dans le monde entier.
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()
Étape 6: Revendiquer la vidéo
L'étape suivante consiste à associer la vidéo mise en ligne à l'élément correspondant en la revendant. La revendication permet d'associer la vidéo au système de gestion des droits de YouTube, qui établit la propriété de la vidéo et permet au propriétaire de définir des règles de monétisation.
La méthode claim_video
revendique les droits audiovisuels. Si vous incluez le paramètre policyId
dans la ligne de commande, la méthode applique la règle spécifiée à la vidéo. Si vous ne l'incluez pas, la méthode applique la règle de monétisation standard.
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()
Étape 7: Définissez les options publicitaires
Nous avons revendiqué la vidéo et lui avons appliqué une règle de monétisation. La dernière étape consiste à spécifier le type d'annonces à diffuser dans la vidéo. Lorsque la règle de monétisation est appliquée, YouTube vérifie les options de publicité et affiche le type de publicités qui génèrent les revenus les plus élevés.
L'exemple indique à YouTube de diffuser des annonces InStream TrueView sur cette vidéo.
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()
Exemple de code complet
L'exemple upload_monetize_video_example.py
fonctionnel complet est répertorié ci-dessous:
#!/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!")