API YouTube pour récupérer toutes les vidéos sur un canal

vous devez regarder le API de données YouTube . Vous y trouverez de la documentation sur la façon d'accéder à L'API. Vous pouvez également trouver bibliothèques clients .

vous pouvez également faire les requêtes vous-même. Voici un exemple D'URL qui récupère les dernières vidéos d'un canal:

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 JSON avec la vidéo id et les détails, et vous pouvez construire votre URL 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 à partir de l'utilisateur / canal:

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

vous pouvez spécifier le nom d'utilisateur avec le forUsername={username} param, ou spécifier mine=true pour obtenir votre propre (vous devez d'abord vous authentifier). Incluez part=contentDetails pour voir les sélections.

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" listes de lecture. Prenez ce numéro de playlist "upload" . Notez également que le "id" est votre channelID pour référence future.

ensuite, obtenez une liste de vidéos dans cette sélection:

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

il suffit de déposer dans 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 de développeurs Google montrant comment répertorier toutes les vidéos dans un canal dans v3 de L'API YouTube.

il y a deux étapes:

1. canaux de requête pour obtenir l'Id" uploads". par exemple, https://www.googleapis.com/youtube/v3/channels?id={channel Id}&key={API key}&part=contentDetails
2. Utilisez cet Id" uploads " pour interroger PlaylistItems pour obtenir la liste des vidéos. par exemple, https://www.googleapis.com/youtube/v3/playlistItems?playlistId={"uploads" Id}&key={API key}&part=snippet&maxResults=50

essayez avec ce qui suit. Il peut vous aider.

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

ici l'auteur comme vous pouvez spécifier votre nom de canal et" q " comme vous pouvez donner votre mot clé de recherche.

ci-dessous est une alternative Python qui ne nécessite pas de paquets spéciaux. En fournissant l'id du canal renvoie une liste de liens vidéo pour ce canal. 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

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 créé un script / outil en ligne que l'on peut utiliser pour obtenir toutes les vidéos d'un canal.

il combine les appels API à youtube.channels.list , playlistItems , videos . Il utilise des fonctions récursives pour faire de l'asynchrone rappels exécuter la prochaine itération à obtenir une réponse valide.

cela sert aussi à limiter le nombre réel de requêtes faites à la fois, donc vous garder en sécurité de violation des règles de L'API YouTube. Partage de morceaux raccourcis et ensuite un lien vers le code complet. J'ai obtenu environ la limite de 50 Résultats max par appel en utilisant la valeur nextPageToken qui vient dans la réponse pour aller chercher les 50 prochains résultats 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.
             }
    });
}

ceci a obtenu une liste de base des vidéos, y compris l'id, le titre, la date de publication et similaire. Mais pour obtenir plus de détails sur chaque vidéo comme view counts and likes, Il faut faire des appels API vers 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 la code complet ici , et version live ici . (Edit: correction du lien github)

voici le code qui vous permettra de retourner toutes les identifications vidéo sous votre canal

<?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);

Note : vous pouvez obtenir l'id du canal à https://www.youtube.com/account_advanced après s'être connecté.

en utilisant la version 2 de L'API, qui est dépréciée, L'URL pour les téléchargements (du canal UCqAEtEr0A0Eo2IVcuWBfB9g) est:

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

il y a une API version 3.

puisque tout le monde qui répond à cette question a des problèmes dus à la 500 limite vidéo voici une solution alternative en utilisant youtube_dl dans Python 3 . Aussi, aucune clé API n'est nécessaire .

1. Installer youtube_dl: sudo pip3 install youtube-dl
2. trouvez l'id du canal de votre cible . L'identification va commencer avec UC. Remplacer le canal C par U pour Upload (C'est-à-dire UU...), il s'agit de la upload playlist .
3. utiliser la playlist downloader feature de youtube-dl. Idéalement, vous ne voulez pas télécharger toutes les vidéos dans la liste de lecture qui est la valeur par défaut, mais seulement 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))

récemment, j'ai dû récupérer toutes les vidéos d'un canal, et selon la documentation de développeur 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ù $service est votre objet Google_Service_YouTube .

vous devez donc aller chercher des informations sur le canal pour récupérer la liste de lecture "uploads" qui contient toutes les vidéos téléchargées par le canal: https://developers.google.com/youtube/v3/docs/channels/list

si cette API est nouvelle, je recommande fortement de transformer l'échantillon de code de l'extrait par défaut à l'échantillon complet.

ainsi le code de base pour récupérer toutes les vidéos d'un canal 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>';

comme l'indique la documentation ( lien ), vous pouvez utiliser la liste des types de ressources de canaux et des opérations pour obtenir toutes les vidéos dans un canal. Cette opération doit être effectuée en utilisant l'argument "channel id".