Uploading video to YouTube and adding it to playlist using YouTube Data API v3 in Python
Question: I wrote a script to upload a video to YouTube using YouTube Data API v3 in the
python with help of example given in [Example
code](https://developers.google.com/youtube/v3/guides/uploading_a_video).

And I wrote another script to add uploaded video to playlist using same
YouTube Data API v3 you can be seen
[here](https://github.com/alokmahor/add_to_youtube_playlist/blob/master/playlist.py)

After that I wrote a single script to upload video and add that video to
playlist. In that I took care of authentication and scops still I am getting
permission error. here is my new script

    
    
    #!/usr/bin/python
    
    import httplib
    import httplib2
    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
    
    # 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]
    CLIENT_SECRETS_FILE = "client_secrets.json"
    
    # A limited OAuth 2 access scope that allows for uploading files, but not other
    # types of account access.
    YOUTUBE_UPLOAD_SCOPE = "https://www.googleapis.com/auth/youtube.upload"
    YOUTUBE_API_SERVICE_NAME = "youtube"
    YOUTUBE_API_VERSION = "v3"
    
    # 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 will need to populate the client_secrets.json file
    found at:
    
       %s
    
    with information from the APIs Console
    https://code.google.com/apis/console#access
    
    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 get_authenticated_service():
      flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE, scope=YOUTUBE_UPLOAD_SCOPE,
        message=MISSING_CLIENT_SECRETS_MESSAGE)
    
      storage = Storage("%s-oauth2.json" % sys.argv[0])
      credentials = storage.get()
    
      if credentials is None or credentials.invalid:
        credentials = run(flow, storage)
    
      return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
        http=credentials.authorize(httplib2.Http()))
    
    
    def initialize_upload(title,description,keywords,privacyStatus,file):
      youtube = get_authenticated_service()
    
      tags = None
      if keywords:
        tags = keywords.split(",")
    
      insert_request = youtube.videos().insert(
        part="snippet,status",
        body=dict(
          snippet=dict(
            title=title,
            description=description,
            tags=tags,
            categoryId='26'
          ),
          status=dict(
            privacyStatus=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(file, chunksize=-1, resumable=True)
      )
    
      vid=resumable_upload(insert_request)
    
      #Here I added lines to add video to playlist
      #add_video_to_playlist(youtube,vid,"PL2JW1S4IMwYubm06iDKfDsmWVB-J8funQ")
      #youtube = get_authenticated_service()
      add_video_request=youtube.playlistItems().insert(
            part="snippet",
            body={
                    'snippet': {
                      'playlistId': "PL2JW1S4IMwYubm06iDKfDsmWVB-J8funQ", 
                      'resourceId': {
                              'kind': 'youtube#video',
                          'videoId': vid
                        }
                    #'position': 0
                    }
            }
        ).execute()
    
    
    def resumable_upload(insert_request):
      response = None
      error = None
      retry = 0
      vid=None
      while response is None:
        try:
          print "Uploading file..."
          status, response = insert_request.next_chunk()
          if 'id' in response:
            print "'%s' (video id: %s) was successfully uploaded." % (
              title, response['id'])
        vid=response['id']
          else:
            exit("The upload failed with an unexpected response: %s" % response)
        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:
          print error
          retry += 1
          if retry > MAX_RETRIES:
            exit("No longer attempting to retry.")
    
          max_sleep = 2 ** retry
          sleep_seconds = random.random() * max_sleep
          print "Sleeping %f seconds and then retrying..." % sleep_seconds
          time.sleep(sleep_seconds)
      return vid  
    
    if __name__ == '__main__':
    
      title="sample title"
      description="sample description"
    
      keywords="keyword1,keyword2,keyword3"
    
      privacyStatus="public"
      file="myfile.mp4"
      vid=initialize_upload(title,description,keywords,privacyStatus,file)
      print 'video ID is :',vid
    

I am not able to figure out what is wrong. I am getting permission error. both
script works fine independently.

could anyone help me figure out where I am wrong or how to achieve uploading
video and adding that too playlist.


Answer: I got the answer actually in both the independent script scope is different.  
scope for uploading is "<https://www.googleapis.com/auth/youtube.upload>"  
scope for adding to playlist is "<https://www.googleapis.com/auth/youtube>"

as scope is different so I had to handle authentication separately.

