Youtube Data API for handling videos | Code Companion

Ashish khuraishyAshish khuraishy December 06, 2018
Youtube Data API for handling videos

Before proceeding further let’s have a look at what we have in store for the videos section. Youtube Data API allows to perform following operations on the video:
  • list
  • insert
  • update
  • rate
  • getRating
  • reportAbuse
  • delete
Let’s discuss how to use Youtube Data API for handling videos.
Please follow the steps below to enable the API and start using it.
  1. Create New Project, Enable API and Create Credentials: In this step we will create a project and will enable the API.
    • Go to Google Developers Console and Click on Sign In in the upper rightmost corner of the page. Sign In using the credentials of the valid Google Account. If you don’t have a google account, setup a account first and then use the details to Sign In on the Google Developers Homepage.
    • Now navigate to the Developer Dashboard and create a new Project.
    • Click on Enable API option.
    • In the search field, search for Youtube Data API and select the Youtube Data API option that comes in the drop down list.
    • You will be redirected to a screen that says information about the Youtube Data API, along with two options : ENABLE and TRY API
    • Click on ENABLE option to get started with the API.
    • In the sidebar under APIs & Services, select Credentials.
    • In the Credentials tab, select the Create credentials drop-down list, and choose API key.
      There are two types of Credentials: API Key and OAuth. OAuth provides you with Client Id and a Secret Key in the form of a .json file. OAuth is generally used where authorization is required like in the case of retrieving liked videos of a user. So for the rest cases where authorization is not required like searching for the videos using a keyword or for searching for the related videos etc, we will be using API Key.
  2. Installation: Google API client for python can be installed using simple pip command:
    pip install --upgrade google-api-python-client
Code for list methods:
  1. List video by Video Id: Below example shows how to retrieve details about a specific video identified by the video Id mentioned in the parameter list.


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# import libraries 
from apiclient.discovery import build 
import pprint 

# arguments to be passed to build function 
DEVELOPER_KEY = "Your_developer_key"
YOUTUBE_API_SERVICE_NAME = "youtube"
YOUTUBE_API_VERSION = "v3"

# creating youtube resource object 
# for interacting with API 
youtube = build(YOUTUBE_API_SERVICE_NAME, 
     YOUTUBE_API_VERSION, 
   developerKey = DEVELOPER_KEY) 


def video_details(video_id): 

 # Call the videos.list method 
 # to retrieve video info 
 list_videos_byid = youtube.videos().list(id = video_id, 
  part = "id, snippet, contentDetails, statistics", 
           ).execute() 

# extracting the results from search response 
 results = list_videos_byid.get("items", []) 

 # empty list to store video details 
 videos = [] 
 
 for result in results: 
  videos.append("% s (% s) (% s) (% s) (% s)" % (result["snippet"]["title"], 
              result["snippet"]["tags"], 
            result['snippet']['description'], 
            result["snippet"]["publishedAt"], 
        result['contentDetails'], result["statistics"])) 
  
 print("Videos:\n", "\n".join(videos), "\n") 
 
if __name__ == "__main__": 

 video_id = "vTaxdJ6VYWE"
 video_details(video_id)

  1. Output:
  2. List videos by Multiple Video Ids: Below example shows how to retrieve information about multiple videos, identified by the multiple video Ids mentioned in the parameter list.

1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# import libraries 
from apiclient.discovery import build 
import pprint 

# arguments to be passed to build function 
DEVELOPER_KEY = "developer_key"
YOUTUBE_API_SERVICE_NAME = "youtube"
YOUTUBE_API_VERSION = "v3"

# creating youtube resource 
# object for interacting with API 
youtube = build(YOUTUBE_API_SERVICE_NAME, 
     YOUTUBE_API_VERSION, 
   developerKey = DEVELOPER_KEY) 

def multiple_video_details(): 

 # Call the videos.list method 
 # to retrieve video info 
 list_videos_byid = youtube.videos().list( 
   id = 'Ks-_Mh1QhMc, c0KYU2j0TM4', 
 part = "id, snippet, contentDetails, statistics", 
        ).execute() 

# extracting the results from search response 
 results = list_videos_byid.get("items", []) 
 # empty list to store video details 
 videos = [] 
 n = 1
 for result in results: 
  videos.append("% s (% s) (% s) (% s) (% s) (% s) (% s)"
       % (n, result["snippet"]["title"], 
         result["snippet"]["tags"], 
         result['snippet']['description'], 
         result["snippet"]["publishedAt"], 
         result['contentDetails'], 
         result["statistics"])) 
  n = n + 1
  
 print ("Videos:\n", "\n".join(videos), "\n") 
 
if __name__ == "__main__": 
 multiple_video_details()



  1. Output:
    2. Note: We have used only limited parameters in the above example. There are many other parameters that can be set and if not set then what default value they take can be found from Youtube Videos List Documentation. Please refer to the documentation to have a full understanding of the available parameters.
    We have recently discussed first two variants of video list method, Video List by Video Id and Video List by Multiple Video Ids. Now, let’s discuss the other two variants –
    • Video List Most Popular Videos
    • Video List My Liked Videos
    • List most popular videos: The regionCode parameter states the country for which you are retrieving videos. videoCategoryId parameter can be set to retrieve most popular videos in a particular category.


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
# import libraries 
from apiclient.discovery import build 
import pprint 

# arguments to be passed to build function 
DEVELOPER_KEY = "Your_developer_key"
YOUTUBE_API_SERVICE_NAME = "youtube"
YOUTUBE_API_VERSION = "v3"

# creating youtube resource object 
# for interacting with API 
youtube = build(YOUTUBE_API_SERVICE_NAME, 
     YOUTUBE_API_VERSION, 
   developerKey = DEVELOPER_KEY) 


def mostpopular_video_details(): 

 # Call the videos.list method to retrieve video info 
 list_videos_byid = youtube.videos().list( 
  part = "id, snippet, contentDetails, statistics", 
    chart ='mostPopular', regionCode ='IN', 
  maxResults = 2, videoCategoryId ='').execute() 

 # extracting the results from search response 
 results = list_videos_byid.get("items", []) 
 
 # empty list to store video details 
 videos = [] 
 n = 1
 for result in results: 
  videos.append("% s (% s) (% s) (% s) (% s) (% s)"
      % (n, result["snippet"]["title"], 
      result['snippet']['description'], 
      result["snippet"]["publishedAt"], 
        result['contentDetails'], 
        result["statistics"])) 
  n = n + 1
  
 print ("Videos:\n", "\n".join(videos), "\n") 
 

if __name__ == "__main__": 
 mostpopular_video_details()

  • Output:
  • List my liked videos: This requires user’s authorization to retrieve a user’s liked videos. By setting the myRating parameter to dislike, one can retrieve the disliked videos. myRating parameter indicates that the search should be done within the authorized user’s account. Since this method requires user’s authentication so we will be creating OAuth type of credential for this example. Follow the steps below to generate a Client Id and a Secret Key.
    1. Go to Google Google Developers Console and Click on Sign In in the upper rightmost corner of the page. Sign In using the credentials of the valid Google Account. If you don’t have a google account, setup an account first and then use the details to Sign In on the Google Developers Homepage.
    2. Now navigate to the Developer Dashboard and create a new Project.
    3. Click on Enable API option.
    4. In the search field, search for Youtube Data API and select the Youtube Data API option that comes in the drop down list.
    5. You will be redirected to a screen that says information about the Youtube Data API, along with two options : ENABLE and TRY API.
    6. Click on ENABLE option to get started with the API.
    7. In the sidebar under APIs & Services, select Credentials.
    8. At the top of the page, select the OAuth consent screen tab. Select an Email address, enter a Product name if not already set, and click the Save button.
    9. In the Credentials tab, select the Create credentials drop-down list, and choose OAuth Client Id. OAuth is generally used where authorization is required like in the case of retrieving liked videos of a user.
    10. Select the application type Other, enter the name “YouTube Data API Myvideos”, and click the Create button and Click OK.
    11. Click on Download button to the right of the client Id to download the JSON file.
    12. Save and rename the file as client_secret.json and move it to the working directory.

    Install additional libraries using the pip command:
    pip install --upgrade google-auth google-auth-oauthlib google-auth-httplib2
    Below is the example:



1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
# importing libraries 
import os 
import google.oauth2.credentials 
import google_auth_oauthlib.flow 
from googleapiclient.discovery import build 
from googleapiclient.errors import HttpError 
from google_auth_oauthlib.flow import InstalledAppFlow 

# The CLIENT_SECRETS_FILE variable specifies 
# the name of a file that contains 
# client_id and client_secret. 
CLIENT_SECRETS_FILE = "client_secret.json"

# This scope allows for full read / write 
# access to the authenticated user's account 
# and requires requests to use an SSL connection. 
SCOPES = ['https://www.googleapis.com / auth / youtube.force-ssl'] 
API_SERVICE_NAME = 'youtube'
API_VERSION = 'v3'

def get_authenticated_service(): 
 
 flow = InstalledAppFlow.from_client_secrets_file( 
      CLIENT_SECRETS_FILE, SCOPES) 
      
 credentials = flow.run_console() 
 return build(API_SERVICE_NAME, API_VERSION, 
     credentials = credentials) 

def print_response(response): 
 print(response) 

# Build a resource based on a list 
# of properties given as key-value pairs. 
# Leave properties with empty values 
# out of the inserted resource. 
def build_resource(properties): 
 resource = {} 
 
 for p in properties: 

  # Given a key like "snippet.title", split 
  # into "snippet" and "title", where 
  # "snippet" will be an object and "title" 
  # will be a property in that object. 
  prop_array = p.split('.') 
  ref = resource 
  
  for pa in range(0, len(prop_array)): 
   is_array = False
   key = prop_array[pa] 
  
   # For properties that have array values, 
   # convert a name like "snippet.tags[]" 
   # to snippet.tags, and set a flag to 
   # handle the value as an array. 
   if key[-2:] == '[]': 
    key = key[0:len(key)-2:] 
    is_array = True
  
   if pa == (len(prop_array) - 1): 

    # Leave properties without values 
    # out of inserted resource. 
    if properties[p]: 
     if is_array: 
      ref[key] = properties[p].split(', ') 
     else: 
      ref[key] = properties[p] 

   elif key not in ref: 

    # For example, the property is "snippet.title", 
    # but the resource does not yet have a "snippet" 
    # object. Create the snippet object here. 
    # Setting "ref = ref[key]" means that in the 
    # next time through the "for pa in range ..." 
    # loop, we will be setting a property in the 
    # resource's "snippet" object. 
    ref[key] = {} 
    ref = ref[key] 

   else: 
    # For example, the property is 
    # "snippet.description", and the resource 
    # already has a "snippet" object. 
    ref = ref[key] 
 return resource 

# Remove keyword arguments that are not set 
def remove_empty_kwargs(**kwargs): 
 
 good_kwargs = {} 
 if kwargs is not None: 
  for key, value in kwargs.items(): 
   if value: 
    good_kwargs[key] = value 
 return good_kwargs 

def videos_list_my_liked_videos(client, **kwargs): 
 kwargs = remove_empty_kwargs(**kwargs) 
 response = client.videos().list(**kwargs).execute() 
 
 return print_response(response) 


if __name__ == '__main__': 
 
 # When running locally, disable OAuthlib's 
 # HTTPs verification. When running in production 
 # *do not * leave this option enabled. 
 os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
 
 client = get_authenticated_service() 
 
 videos_list_my_liked_videos(client, 
  part ='snippet, contentDetails, statistics', 
    myRating ='like', maxResults = 2)

  • Output:


    While executing the code, it will ask for the authorization code. For getting the code we need to follow the link mentioned in the command prompt screen above the line: Enter the Authorization code.
    Now follow the link and copy paste the authorization code got by granting the permission.
    For the convenience, we have set maxResults parameter to 2.
    • Refer to the Youtube Data API Documentation-video.list() for the complete list of parameters.
Tags
Reactions

Post a Comment

0 Comments