API de YouTube para buscar todos los videos en un canal

Necesitamos una lista de videos por nombre de canal de YouTube (usando la API).

Podemos obtener una lista de canales (solo el nombre del canal) utilizando la siguiente API:

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

A continuación se muestra un enlace directo de canales.

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

O

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

Ahora, necesitamos videos del canal >> UCqAEtEr0A0Eo2IVcuWBfB9g o HC-8jgBP-4rlI.

Nosotros tratamos

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=UC7Xayrf2k0NZizQS3

Pero eso no ayuda.

Necesitamos todos los videos publicados en el canal. Los videos cargados en un canal pueden ser de múltiples usuarios, por lo que no creo que proporcionar un parámetro de usuario ayude ...

Debes mirar la API de datos de YouTube . Encontrará allí documentación sobre cómo se puede acceder a la API. También puede encontrar bibliotecas de clientes .

También puede hacer las solicitudes usted mismo. Aquí hay un ejemplo de URL que recupera los últimos videos de un canal:

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

Después de eso, recibirá un JSONidentificador de video y detalles, y puede construir su URL de video de esta manera:

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

Primero, debe obtener el ID de la lista de reproducción que representa las cargas del usuario / canal:

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

Puede especificar el nombre de usuario con el forUsername={username}parámetro o especificar mine=truepara obtener el suyo (primero debe autenticarse). Incluir part=contentDetailspara ver las listas de reproducción.

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

En el resultado "relatedPlaylists"se incluirán "likes"y "uploads"listas de reproducción. Toma esa "upload"ID de la lista de reproducción. También tenga en cuenta que "id"es su channelID para referencia futura.

A continuación, obtenga una lista de videos en esa lista de reproducción:

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

¡Solo deja caer en la lista de reproducción!

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

Aquí hay un video de Google Developers que muestra cómo listar todos los videos en un canal v3de la API de YouTube.

Hay dos pasos:

1. Consultar canales para obtener el ID de "subidas". p.ejhttps://www.googleapis.com/youtube/v3/channels?id={channel Id}&key={API key}&part=contentDetails

2. Use este ID de "cargas" para consultar PlaylistItems para obtener la lista de videos. p.ejhttps://www.googleapis.com/youtube/v3/playlistItems?playlistId={"uploads" Id}&key={API key}&part=snippet&maxResults=50

Para obtener la lista de canales:

Obtener la lista de canales por forUserName :

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

Obtener la lista de canales por id del canal :

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

Obtener secciones del canal:

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

Para obtener listas de reproducción:

Obtenga listas de reproducción por ID de canal :

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

Obtenga listas de reproducción por ID de canal con pageToken :

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

Para obtener artículos de lista de reproducción:

Obtener lista de artículos de lista de reproducción por PlayListId :

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

Para obtener videos:

Obtener lista de videos por ID de video :

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

Obtener lista de videos por ID de videos múltiples :

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

Obtener lista de comentarios

Obtener lista de comentarios por ID de video :

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

Obtener lista de comentarios por ID de canal :

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

Obtener lista de comentarios por allThreadsRelatedToChannelId :

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

Aquí todas las API son Get enfoque.

Según la identificación del canal, no obtenemos todos los videos directamente, ese es el punto importante aquí.

Para la integración https://developers.google.com/youtube/v3/quickstart/ios?ver=swift

A continuación se muestra una alternativa a Python que no requiere ningún paquete especial. Al proporcionar la identificación del canal, devuelve una lista de enlaces de video para ese canal. Tenga en cuenta que necesita una clave API para que funcione.

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

Aquí está el código que devolverá todos los identificadores de video en tu 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);

Nota : Puede obtener la identificación del canal en https://www.youtube.com/account_advanced después de iniciar sesión.

Intenta con lo siguiente. Te puede ayudar.

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

Aquí autor, ya que puede especificar el nombre de su canal y "q", ya que puede dar su palabra clave de búsqueda.

Solo en tres pasos:

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

2. Canales: lista -> 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}

Gracias a las referencias compartidas aquí y en otros lugares, he creado un script / herramienta en línea que se puede utilizar para obtener todos los videos de un canal.

Combina llamadas a la API a youtube.channels.list, playlistItems,videos . Utiliza funciones recursivas para hacer que las devoluciones de llamada asíncronas ejecuten la siguiente iteración al obtener una respuesta válida.

Esto también sirve para limitar el número real de solicitudes realizadas a la vez, por lo que te mantiene a salvo de violar las reglas de la API de YouTube. Compartir fragmentos acortados y luego un enlace al código completo. Obtuve alrededor de la limitación máxima de 50 resultados por llamada usando el valor nextPageToken que viene en la respuesta para obtener los siguientes 50 resultados, y así sucesivamente.

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.
             }
    });
}

Esto obtuvo una lista básica de los videos, incluyendo identificación, título, fecha de publicación y similares. Pero para obtener más detalles de cada video, como recuentos de visitas y me gusta, uno tiene que hacer llamadas a la 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.
            }
});

Vea el código completo aquí y la versión en vivo aquí . (Editar: enlace fijo de github)
Editar: Dependencias: JQuery, Papa.parse

Dado que todos los que responden esta pregunta tienen problemas debido al límite de 500 videos, aquí hay una solución alternativa que usa youtube_dl en Python 3 . Además, no se necesita una clave API .

1. Instala youtube_dl: sudo pip3 install youtube-dl
2. Descubre la identificación del canal de tu canal objetivo . La identificación comenzará con UC. Reemplace la C para el canal con U para la carga (es decir, UU ...), esta es la lista de reproducción de carga .
3. Use la función de descarga de listas de reproducción de youtube-dl. Idealmente, NO desea descargar todos los videos de la lista de reproducción, que es el predeterminado, sino solo los metadatos.

Ejemplo (advertencia: toma decenas de minutos):

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

Con la versión 2 de la API, que está en desuso, la URL para las cargas (del canal UCqAEtEr0A0Eo2IVcuWBfB9g) es:

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

Hay una versión API 3.

Recientemente tuve que recuperar todos los videos de un canal, y de acuerdo con la documentación del desarrollador de 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'));

¿Dónde $serviceestá tu Google_Service_YouTubeobjeto?

Por lo tanto, debe obtener información del canal para recuperar la lista de reproducción de "subidas" que realmente tiene todos los videos subidos por el canal: https://developers.google.com/youtube/v3/docs/channels/list

Si es nuevo con esta API, le recomiendo convertir la muestra de código del fragmento predeterminado a la muestra completa.

Entonces, el código básico para recuperar todos los videos de un canal puede ser:

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>';

Solución de muestra en Python. Ayuda tomada de este video: video Al igual que muchas otras respuestas, la identificación de carga debe recuperarse primero de la identificación del canal.

import urllib.request
importar json

clave = "YOUR_YOUTUBE_API_v3_BROWSER_KEY"

# Lista de canales: mencione si está pegando la identificación del canal o el nombre de usuario - "id" o "forUsername"
ytids = [["bbcnews", "forUsername"], ["UCjq4pjKj9X4W9i7UnYShpVg", "id"]]

newstitles = []
para ytid, ytparam en ytids:
    urld = "https://www.googleapis.com/youtube/v3/channels?part=contentDetails&"+ytparam+"="+ytid+"&key="+key
    con urllib.request.urlopen (urld) como url:
        datad = json.loads (url.read ())
    uploadsdet = datad ['artículos']
    #get id de carga del id del canal
    uploadid = uploadsdet [0] ['contentDetails'] ['relatedPlaylists'] ['uploads']

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

    para datos en datad ['artículos']:
        ntitle = data ['fragmento'] ['título']
        nlink = data ['contentDetails'] ['videoId']
        newstitles.append ([nlink, ntitle])

para enlace, título en newstitles:
    imprimir (enlace, título)

Los enlaces descargados del canal de youtube, no conservan la estructura del directorio. Entonces, escribí un código para que eso suceda. Use esto una vez que descargue los videos de la manera aceptada arriba. ``

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])

``

Como dice la documentación ( enlace ), puede usar el tipo de recurso del canal y la Lista de operaciones para obtener todos los videos en un canal. Esta operación debe realizarse utilizando el argumento 'id del canal'.