API YouTube pour récupérer toutes les vidéos sur une chaîne

Nous avons besoin d'une liste de vidéos par nom de chaîne de YouTube (en utilisant l'API).

Nous pouvons obtenir une liste de chaînes (uniquement le nom de la chaîne) en utilisant l'API ci-dessous:

https://gdata.youtube.com/feeds/api/channels?v=2&q=tendulkar

Ci-dessous un lien direct des chaînes

https://www.youtube.com/channel/UCqAEtEr0A0Eo2IVcuWBfB9g

Ou

WWW.YouTube.com/channel/HC-8jgBP-4rlI

Maintenant, nous avons besoin de vidéos de canal >> UCqAEtEr0A0Eo2IVcuWBfB9g ou HC-8jgBP-4rlI.

Nous avons essayé

https://gdata.youtube.com/feeds/api/videos?v=2&uploader=partner&User=UC7Xayrf2k0NZiz3S04WuDNQ https://gdata.youtube.com/feeds/api/videos?v=2&uploader=partner&q=UC7XayZ

Mais cela n'aide pas.

Nous avons besoin de toutes les vidéos publiées sur la chaîne. Les vidéos téléchargées sur une chaîne peuvent provenir de plusieurs utilisateurs, donc je ne pense pas que fournir un paramètre utilisateur aiderait ...

Vous devez regarder l' API YouTube Data . Vous y trouverez de la documentation sur l'accès à l'API. Vous pouvez également trouver des bibliothèques clientes .

Vous pouvez également faire les demandes vous-même. Voici un exemple d'URL qui récupère les dernières vidéos d'une chaîne:

https://www.googleapis.com/youtube/v3/search?key={your_key_here}&channelId={channel_id_here}&part=snippet,id&order=date&maxResults=20

Après cela, vous recevrez un JSONavec les identifiants et les détails de la vidéo, et vous pourrez construire votre URL de vidéo comme ceci:

http://www.youtube.com/watch?v={video_id_here}

Tout d'abord, vous devez obtenir l'ID de la liste de lecture qui représente les téléchargements de l'utilisateur / chaîne:

https://developers.google.com/youtube/v3/docs/channels/list#try-it

Vous pouvez spécifier le nom d'utilisateur avec le forUsername={username}paramètre ou spécifier mine=truepour obtenir le vôtre (vous devez d'abord vous authentifier). Inclure part=contentDetailspour voir les listes de lecture.

GET https://www.googleapis.com/youtube/v3/channels?part=contentDetails&forUsername=jambrose42&key={YOUR_API_KEY}

Dans le résultat "relatedPlaylists"comprendra "likes"et "uploads"playlists. Saisissez cet "upload"ID de playlist. Notez également que "id"c'est votre channelID pour référence future.

Ensuite, obtenez une liste de vidéos dans cette playlist:

https://developers.google.com/youtube/v3/docs/playlistItems/list#try-it

Déposez simplement le playlistId!

GET https://www.googleapis.com/youtube/v3/playlistItems?part=snippet%2CcontentDetails&maxResults=50&playlistId=UUpRmvjdu3ixew5ahydZ67uA&key={YOUR_API_KEY}

Voici une vidéo des développeurs Google montrant comment répertorier toutes les vidéos d'une chaîne dansv3 l'API YouTube.

Il y a deux étapes:

1. Recherchez les canaux pour obtenir l'ID "uploads". par exemplehttps://www.googleapis.com/youtube/v3/channels?id={channel Id}&key={API key}&part=contentDetails

2. Utilisez cet identifiant "uploads" pour interroger PlaylistItems pour obtenir la liste des vidéos. par exemplehttps://www.googleapis.com/youtube/v3/playlistItems?playlistId={"uploads" Id}&key={API key}&part=snippet&maxResults=50

Pour obtenir la liste des chaînes:

Obtenir la liste des chaînes par forUserName :

https://www.googleapis.com/youtube/v3/channels?part=snippet,contentDetails,statistics&forUsername=Apple&key=

Obtenir la liste des chaînes par identifiant de chaîne :

https://www.googleapis.com/youtube/v3/channels/?part=snippet,contentDetails,statistics&id=UCE_M8A5yxnLfW0KghEeajjw&key=

Obtenir les sections de chaîne:

https://www.googleapis.com/youtube/v3/channelSections?part=snippet,contentDetails&channelId=UCE_M8A5yxnLfW0KghEeajjw&key=

Pour obtenir des listes de lecture:

Obtenir des listes de lecture par ID de chaîne :

https://www.googleapis.com/youtube/v3/playlists?part=snippet,contentDetails&channelId=UCq-Fj5jknLsUf-MWSy4_brA&maxResults=50&key=

Obtenir des listes de lecture par ID de chaîne avec pageToken :

https://www.googleapis.com/youtube/v3/playlists?part=snippet,contentDetails&channelId=UCq-Fj5jknLsUf-MWSy4_brA&maxResults=50&key= & pageToken = CDIQAA

Pour obtenir des PlaylistItems:

Obtenez la liste PlaylistItems par PlayListId :

https://www.googleapis.com/youtube/v3/playlistItems?part=snippet,contentDetails&maxResults=25&playlistId=PLHFlHpPjgk70Yv3kxQvkDEO5n5tMQia5I&key=

Pour obtenir des vidéos:

Obtenez la liste des vidéos par identifiant vidéo :

https://www.googleapis.com/youtube/v3/videos?part=snippet,contentDetails,statistics&id=YxLCwfA1cLw&key=

Obtenez la liste des vidéos par plusieurs identifiants de vidéos :

https://www.googleapis.com/youtube/v3/videos?part=snippet,contentDetails,statistics&id=YxLCwfA1cLw,Qgy6LaO3SB0,7yPJXGO2Dcw&key=

Avoir liste des commentaires

Obtenir la liste des commentaires par ID vidéo :

https://www.googleapis.com/youtube/v3/commentThreads?part=snippet,replies&videoId=el **** kQQak & key = A ********** k

Obtenir la liste des commentaires par ID de chaîne :

https://www.googleapis.com/youtube/v3/commentThreads?part=snippet,replies&channelId=U ***** Q & key = AI ******** k

Obtenir la liste des commentaires de allThreadsRelatedToChannelId :

https://www.googleapis.com/youtube/v3/commentThreads?part=snippet,replies&allThreadsRelatedToChannelId=UC ***** ntcQ & key = AI ***** k

Ici, toutes les API sont Get approche .

En fonction de l'identifiant de la chaîne, nous n'obtenons pas toutes les vidéos directement, c'est le point important ici.

Pour l'intégration https://developers.google.com/youtube/v3/quickstart/ios?ver=swift

Vous trouverez ci-dessous une alternative Python qui ne nécessite aucun package spécial. En fournissant l'ID de chaîne, il renvoie une liste de liens vidéo pour cette chaîne. Veuillez noter que vous avez besoin d'une clé API pour que cela fonctionne.

import urllib
import json

def get_all_video_in_channel(channel_id):
    api_key = YOUR API KEY

    base_video_url = 'https://www.youtube.com/watch?v='
    base_search_url = 'https://www.googleapis.com/youtube/v3/search?'

    first_url = base_search_url+'key={}&channelId={}&part=snippet,id&order=date&maxResults=25'.format(api_key, channel_id)

    video_links = []
    url = first_url
    while True:
        inp = urllib.urlopen(url)
        resp = json.load(inp)

        for i in resp['items']:
            if i['id']['kind'] == "youtube#video":
                video_links.append(base_video_url + i['id']['videoId'])

        try:
            next_page_token = resp['nextPageToken']
            url = first_url + '&pageToken={}'.format(next_page_token)
        except:
            break
    return video_links

Voici le code qui renverra tous les identifiants vidéo sous votre chaîne

<?php 
    $baseUrl = 'https://www.googleapis.com/youtube/v3/';
    // https://developers.google.com/youtube/v3/getting-started
    $apiKey = 'API_KEY';
    // If you don't know the channel ID see below
    $channelId = 'CHANNEL_ID';

    $params = [
        'id'=> $channelId,
        'part'=> 'contentDetails',
        'key'=> $apiKey
    ];
    $url = $baseUrl . 'channels?' . http_build_query($params);
    $json = json_decode(file_get_contents($url), true);

    $playlist = $json['items'][0]['contentDetails']['relatedPlaylists']['uploads'];

    $params = [
        'part'=> 'snippet',
        'playlistId' => $playlist,
        'maxResults'=> '50',
        'key'=> $apiKey
    ];
    $url = $baseUrl . 'playlistItems?' . http_build_query($params);
    $json = json_decode(file_get_contents($url), true);

    $videos = [];
    foreach($json['items'] as $video)
        $videos[] = $video['snippet']['resourceId']['videoId'];

    while(isset($json['nextPageToken'])){
        $nextUrl = $url . '&pageToken=' . $json['nextPageToken'];
        $json = json_decode(file_get_contents($nextUrl), true);
        foreach($json['items'] as $video)
            $videos[] = $video['snippet']['resourceId']['videoId'];
    }
    print_r($videos);

Remarque : Vous pouvez obtenir l'identifiant de la chaîne sur https://www.youtube.com/account_advanced après vous être connecté.

Essayez comme suit. Cela peut vous aider.

https://gdata.youtube.com/feeds/api/videos?author=cnn&v=2&orderby=updated&alt=jsonc&q=news

Ici auteur comme vous pouvez spécifier le nom de votre chaîne et "q" comme vous pouvez donner votre mot clé de recherche.

Juste en trois étapes:

1. Abonnements: liste -> https://www.googleapis.com/youtube/v3/subscriptions?part=snippet&maxResults=50&mine=true&access_token= {oauth_token}

2. Chaînes: liste -> https://www.googleapis.com/youtube/v3/channels?part=contentDetails&id= {channel_id} & key = {YOUR_API_KEY}

3. PlaylistItems: list -> https://www.googleapis.com/youtube/v3/playlistItems?part=snippet&playlistId= {playlist_id} & key = {YOUR_API_KEY}

Grâce aux références partagées ici et ailleurs, j'ai réalisé un script / outil en ligne que l'on peut utiliser pour obtenir toutes les vidéos d'une chaîne.

Il combine les appels API à youtube.channels.list, playlistItems, videos. Il utilise des fonctions récursives pour que les rappels asynchrones exécutent la prochaine itération lors de l'obtention d'une réponse valide.

Cela permet également de limiter le nombre réel de demandes effectuées à la fois, vous évitant ainsi de violer les règles de l'API YouTube. Partager des extraits abrégés, puis un lien vers le code complet. J'ai réussi à contourner les 50 résultats maximum par appel en utilisant la valeur nextPageToken qui vient dans la réponse pour récupérer les 50 résultats suivants et ainsi de suite.

function getVideos(nextPageToken, vidsDone, params) {
    $.getJSON("https://www.googleapis.com/youtube/v3/playlistItems", {
        key: params.accessKey,
        part: "snippet",
        maxResults: 50,
        playlistId: params.playlistId,
        fields: "items(snippet(publishedAt, resourceId/videoId, title)), nextPageToken",
        pageToken: ( nextPageToken || '')
        },
        function(data) {
            // commands to process JSON variable, extract the 50 videos info

            if ( vidsDone < params.vidslimit) {

                // Recursive: the function is calling itself if
                // all videos haven't been loaded yet
                getVideos( data.nextPageToken, vidsDone, params);

            }
             else {
                 // Closing actions to do once we have listed the videos needed.
             }
    });
}

Cela a obtenu une liste de base des vidéos, y compris l'identifiant, le titre, la date de publication et similaires. Mais pour obtenir plus de détails sur chaque vidéo, comme le nombre de vues et les likes, il faut passer des appels à l'API videos.

// Looping through an array of video id's
function fetchViddetails(i) {
    $.getJSON("https://www.googleapis.com/youtube/v3/videos", {
        key: document.getElementById("accesskey").value,
        part: "snippet,statistics",
        id: vidsList[i]
        }, function(data) {

            // Commands to process JSON variable, extract the video
            // information and push it to a global array
            if (i < vidsList.length - 1) {
                fetchViddetails(i+1) // Recursive: calls itself if the
                                     //            list isn't over.
            }
});

Voir le code complet ici et la version live ici . (Edit: lien github fixe)
Edit: Dépendances: JQuery, Papa.parse

Étant donné que tous ceux qui répondent à cette question ont des problèmes en raison de la limite de 500 vidéos, voici une solution alternative utilisant youtube_dl en Python 3 . De plus, aucune clé API n'est nécessaire .

1. Installez youtube_dl: sudo pip3 install youtube-dl
2. Découvrez l'identifiant de canal de votre chaîne cible . L'ID va commencer par UC. Remplacez le C pour la chaîne par U pour le téléchargement (c'est-à-dire UU ...), c'est la playlist de téléchargement .
3. Utilisez la fonction de téléchargement de listes de lecture de YouTube-DL. Idéalement, vous ne voulez PAS télécharger chaque vidéo de la liste de lecture qui est la valeur par défaut, mais uniquement les métadonnées.

Exemple (avertissement - prend des dizaines de minutes):

import youtube_dl, pickle

             # UCVTyTA7-g9nopHeHbeuvpRA is the channel id (1517+ videos)
PLAYLIST_ID = 'UUVTyTA7-g9nopHeHbeuvpRA'  # Late Night with Seth Meyers

with youtube_dl.YoutubeDL({'ignoreerrors': True}) as ydl:

    playd = ydl.extract_info(PLAYLIST_ID, download=False)

    with open('playlist.pickle', 'wb') as f:
        pickle.dump(playd, f, pickle.HIGHEST_PROTOCOL)

    vids = [vid for vid in playd['entries'] if 'A Closer Look' in vid['title']]
    print(sum('Trump' in vid['title'] for vid in vids), '/', len(vids))

En utilisant l'API version 2, qui est obsolète, l'URL pour les téléchargements (du canal UCqAEtEr0A0Eo2IVcuWBfB9g) est:

https://gdata.youtube.com/feeds/users/UCqAEtEr0A0Eo2IVcuWBfB9g/uploads

Il existe une version 3 de l'API.

Récemment, j'ai dû récupérer toutes les vidéos d'une chaîne, et selon la documentation des développeurs YouTube: https://developers.google.com/youtube/v3/docs/playlistItems/list

function playlistItemsListByPlaylistId($service, $part, $params) {
    $params = array_filter($params);
    $response = $service->playlistItems->listPlaylistItems(
        $part,
        $params
    );

    print_r($response);
}

playlistItemsListByPlaylistId($service,
    'snippet,contentDetails',
    array('maxResults' => 25, 'playlistId' => 'id of "uploads" playlist'));

Où $serviceest tonGoogle_Service_YouTube objet.

Vous devez donc récupérer les informations de la chaîne pour récupérer la playlist "uploads" qui contient en fait toutes les vidéos téléchargées par la chaîne: https://developers.google.com/youtube/v3/docs/channels/list

Si vous êtes nouveau avec cette API, je vous recommande fortement de transformer l'exemple de code de l'extrait par défaut en exemple complet.

Ainsi, le code de base pour récupérer toutes les vidéos d'une chaîne peut être:

class YouTube
{
    const       DEV_KEY = 'YOUR_DEVELOPPER_KEY';
    private     $client;
    private     $youtube;
    private     $lastChannel;

    public function __construct()
    {
        $this->client = new Google_Client();
        $this->client->setDeveloperKey(self::DEV_KEY);
        $this->youtube = new Google_Service_YouTube($this->client);
        $this->lastChannel = false;
    }

    public function getChannelInfoFromName($channel_name)
    {
        if ($this->lastChannel && $this->lastChannel['modelData']['items'][0]['snippet']['title'] == $channel_name)
        {
            return $this->lastChannel;
        }
        $this->lastChannel = $this->youtube->channels->listChannels('snippet, contentDetails, statistics', array(
            'forUsername' => $channel_name,
        ));
        return ($this->lastChannel);
    }

    public function getVideosFromChannelName($channel_name, $max_result = 5)
    {
        $this->getChannelInfoFromName($channel_name);
        $params = [
            'playlistId' => $this->lastChannel['modelData']['items'][0]['contentDetails']['relatedPlaylists']['uploads'],
            'maxResults'=> $max_result,
        ];
        return ($this->youtube->playlistItems->listPlaylistItems('snippet,contentDetails', $params));
    }
}

$yt = new YouTube();
echo '<pre>' . print_r($yt->getVideosFromChannelName('CHANNEL_NAME'), true) . '</pre>';

Exemple de solution en Python. Aide tirée de cette vidéo: vidéo Comme beaucoup d'autres réponses, l'identifiant de téléchargement doit d'abord être récupéré à partir de l'identifiant de la chaîne.

import urllib.request
importer json

key = "YOUR_YOUTUBE_API_v3_BROWSER_KEY"

#Liste des chaînes: indiquez si vous collez l'identifiant ou le nom d'utilisateur de la chaîne - "id" ou "forUsername"
ytids = [["bbcnews", "forUsername"], ["UCjq4pjKj9X4W9i7UnYShpVg", "id"]]]

newstitles = []
pour ytid, ytparam en ytids:
    urld = "https://www.googleapis.com/youtube/v3/channels?part=contentDetails&"+ytparam+"="+ytid+"&key="+key
    avec urllib.request.urlopen (urld) comme url:
        datad = json.loads (url.read ())
    uploadsdet = datad ['items']
    #get id de téléchargement à partir de l'ID de canal
    uploadid = uploadsdet [0] ['contentDetails'] ['relatedPlaylists'] ['uploads']

    #retrieve list
    urld = "https://www.googleapis.com/youtube/v3/playlistItems?part=snippet%2CcontentDetails&maxResults=50&playlistId="+uploadid+"&key="+key
    avec urllib.request.urlopen (urld) comme url:
        datad = json.loads (url.read ())

    pour les données dans datad ['items']:
        ntitle = data ['snippet'] ['title']
        nlink = data ['contentDetails'] ['videoId']
        newstitles.append ([nlink, ntitle])

pour le lien, le titre en newstitles:
    imprimer (lien, titre)

Les liens téléchargés à partir de la chaîne YouTube ne préservent pas la structure du répertoire. J'ai donc écrit un code pour que cela se produise. Utilisez-le une fois que vous téléchargez les vidéos de la manière acceptée ci-dessus. "

def play_vid(channel):
    yset = dict()
    temp = []
    link = channel + '/playlists'
    first = urlopen(link)
    bs = BeautifulSoup(first.read(), 'html.parser')
    for i in bs.find_all('a', {'class':'yt-uix-sessionlink yt-uix-tile-link spf-link yt-ui-ellipsis yt-ui-ellipsis-2'}):
        print('Creating list for the playlist: ', i.get_text())
        link = 'https://www.youtube.com'+i.get('href')
#         print(link)
        first = urlopen(link)
        bsp = BeautifulSoup(first.read(), 'html.parser')
        res=bsp.find_all('a',{'class':'pl-video-title-link'})
        for l in res:
            temp.append(l.get_text().replace(" ", "").strip())
        yset[i.get_text()]=temp
        temp=[]
    print("Done!!")
    return yset



checking = play_vid('https://www.youtube.com/user/NinjaTraderLLC')


'''for me /media/shivam/BIG/ninja is the folder where i've previously downloaded all the videos from channel'''    
downloaded = [file for file in os.listdir('/media/shivam/BIG/ninja/') if os.path.isfile('/media/shivam/BIG/ninja/'+file)]

hash_table = dict()
for i in downloaded:
    hash_table[i.replace(" ", "")] = i

for i in scraped.keys():

    if os.path.isdir('/media/shivam/BIG/ninja/'+ i):
        pass
    else:
        os.mkdir('/media/shivam/BIG/ninja/'+ i)
    minn = 1000
    mov = ""

    for j in scraped[i]:
        for k in hash_table.keys():
            if nltk.edit_distance(j, k) < minn:
                minn = nltk.edit_distance(j, k)
                mov = k
        minn = 1000
        print("Moving ",mov, "for  channel: ",j)
        shutil.copy('/media/shivam/BIG/ninja/'+ hash_table[mov], '/media/shivam/BIG/ninja/'+ i +'/'+hash_table[mov])

"

Comme l'indique la documentation ( lien ), vous pouvez utiliser le type de ressource de chaîne et la liste des opérations pour obtenir toutes les vidéos d'une chaîne. Cette opération doit être effectuée à l'aide de l'argument 'id canal'.