API do YouTube para buscar todos os vídeos em um canal

Precisamos de uma lista de vídeos pelo nome do canal do YouTube (usando a API).

Podemos obter uma lista de canais (apenas o nome do canal) usando a API abaixo:

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

Abaixo está um link direto de canais

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

Ou

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

Agora, precisamos de vídeos do canal >> UCqAEtEr0A0Eo2IVcuWBfB9g ou HC-8jgBP-4rlI.

Nós tentamos

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

Mas isso não ajuda.

Precisamos de todos os vídeos postados no canal. Os vídeos enviados para um canal podem ser de vários usuários, portanto, não acho que fornecer um parâmetro de usuário ajudaria ...

Você precisa olhar para a API de dados do YouTube . Você encontrará documentação sobre como a API pode ser acessada. Você também pode encontrar bibliotecas clientes .

Você também pode fazer os pedidos você mesmo. Aqui está um exemplo de URL que recupera os vídeos mais recentes de um canal:

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

Depois disso, você receberá um JSONID e detalhes do vídeo e poderá construir o URL do seu vídeo assim:

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

Primeiro, você precisa obter o ID da lista de reprodução que representa os envios do usuário / canal:

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

Você pode especificar o nome de usuário com o forUsername={username}parâmetro ou especificar mine=truepara obter o seu próprio (você precisa se autenticar primeiro). Incluir part=contentDetailspara ver as listas de reprodução.

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

No resultado "relatedPlaylists"incluirá "likes"e "uploads"playlists. Pegue esse "upload"ID da lista de reprodução. Observe também que "id"é o seu channelID para referência futura.

Em seguida, obtenha uma lista de vídeos nessa lista de reprodução:

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

Basta soltar na playlistId!

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

Aqui está um vídeo do Google Developers mostrando como listar todos os vídeos em um canal emv3 da API do YouTube.

Existem dois passos:

1. Canais de consulta para obter o ID de "uploads". por exemplohttps://www.googleapis.com/youtube/v3/channels?id={channel Id}&key={API key}&part=contentDetails

2. Use esse ID de "uploads" para consultar os itens da Playlist e obter a lista de vídeos. por exemplohttps://www.googleapis.com/youtube/v3/playlistItems?playlistId={"uploads" Id}&key={API key}&part=snippet&maxResults=50

Para obter a lista de canais:

Obter Lista de canais por forUserName :

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

Obter lista de canais por ID de canal :

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

Obter seções do canal:

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

Para obter listas de reprodução:

Obter listas de reprodução por ID do canal :

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

Obter Listas de reprodução por ID do canal com o pageToken :

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

Para obter os PlaylistItems:

Obtenha a lista de itens de Playlist por PlayListId :

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

Para obter vídeos:

Obter lista de vídeos por ID de vídeo :

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

Obter lista de vídeos por vários IDs de vídeos :

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

Obter lista de comentários

Obter lista de comentários por ID do vídeo :

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

Obter lista de comentários por ID do canal :

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

Obter lista de comentários por allThreadsRelatedToChannelId :

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

Aqui todas as APIs são Get abordagem .

Com base no ID do canal, não temos todos os vídeos diretamente, esse é o ponto importante aqui.

Para integração https://developers.google.com/youtube/v3/quickstart/ios?ver=swift

Abaixo está uma alternativa Python que não requer nenhum pacote especial. Ao fornecer o ID do canal, ele retorna uma lista de links de vídeo para esse canal. Observe que você precisa de uma chave de API para que ela 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

Aqui está o código que retornará todos os IDs de vídeo do seu 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 : você pode obter o ID do canal em https://www.youtube.com/account_advanced após fazer login.

Tente com o seguinte. Isso pode ajudá-lo.

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

Aqui, escreva como você pode especificar o nome do canal e "q", assim como a palavra-chave de pesquisa.

Apenas em três etapas:

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

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

Graças às referências compartilhadas aqui e em outros lugares, criei um script / ferramenta on-line que pode ser usado para obter todos os vídeos de um canal.

Ele combina chamadas de API para youtube.channels.list, playlistItems,videos . Ele usa funções recursivas para fazer com que os retornos de chamada assíncronos executem a próxima iteração ao obter uma resposta válida.

Isso também serve para limitar o número real de solicitações feitas por vez, mantendo-o protegido contra violações das regras da API do YouTube. Compartilhando trechos reduzidos e, em seguida, um link para o código completo. Consegui contornar os 50 resultados máximos por limitação de chamada usando o valor nextPageToken que vem na resposta para buscar os próximos 50 resultados e assim por diante.

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

Isso obteve uma lista básica dos vídeos, incluindo ID, título, data de publicação e similares. Mas, para obter mais detalhes de cada vídeo, como contagens e curtidas, é necessário fazer chamadas de 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.
            }
});

Veja o código completo aqui e a versão ao vivo aqui . (Editar: link fixo do github)
Editar: Dependências: JQuery, Papa.parse

Como todo mundo que responde a essa pergunta tem problemas devido ao limite de 500 vídeos, aqui está uma solução alternativa usando o youtube_dl no Python 3 . Além disso, nenhuma chave de API é necessária .

1. Instale youtube_dl: sudo pip3 install youtube-dl
2. Descubra o ID do canal do seu destino . O ID começará com UC. Substitua C do canal por U para upload (ou seja, UU ...), esta é a lista de reprodução de upload .
3. Use o recurso de download da lista de reprodução do youtube-dl. Idealmente, você NÃO deseja fazer o download de todos os vídeos na lista de reprodução, que é o padrão, mas apenas os metadados.

Exemplo (aviso - leva dezenas 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))

Usando a API versão 2, que está obsoleta, o URL para uploads (do canal UCqAEtEr0A0Eo2IVcuWBfB9g) é:

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

Existe uma versão 3 da API.

Recentemente, tive que recuperar todos os vídeos de um canal e, de acordo com a documentação do desenvolvedor do 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'));

Onde $serviceestá o seu Google_Service_YouTubeobjeto?

Portanto, você deve buscar informações no canal para recuperar a lista de reprodução "uploads" que realmente possui todos os vídeos enviados pelo canal: https://developers.google.com/youtube/v3/docs/channels/list

Se for novo com esta API, recomendo transformar a amostra de código do snippet padrão para a amostra completa.

Portanto, o código básico para recuperar todos os vídeos de um canal pode 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>';

Solução de exemplo em Python. Ajuda extraída deste vídeo: video Como muitas outras respostas, o ID do upload deve ser recuperado primeiro do ID do canal.

import urllib.request
json de importação

key = "YOUR_YOUTUBE_API_v3_BROWSER_KEY"

#List of channels: mencione se você está colando o ID ou o nome de usuário do canal - "id" ou "forUsername"
ytids = [["bbcnews", "forUsername"], ["UCjq4pjKj9X4W9i7UnYShpVg", "id"]]

newstitles = []
para ytid, ytparam em ytids:
    urld = "https://www.googleapis.com/youtube/v3/channels?part=contentDetails&"+ytparam+"="+ytid+"&key="+key
    com urllib.request.urlopen (urld) como url:
        datad = json.loads (url.read ())
    uploadsdet = datad ['itens']
    #get upload id from channel id
    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
    com urllib.request.urlopen (urld) como url:
        datad = json.loads (url.read ())

    para dados no datad ['itens']:
        ntitle = data ['trecho'] ['título']
        nlink = data ['contentDetails'] ['videoId']
        newstitles.append ([nlink, ntitle])

para link, título em novos artigos:
    imprimir (link, título)

Links baixados do canal do youtube, não preservam a estrutura de diretórios. Então, eu escrevi um código para fazer isso acontecer. Use isso depois de baixar os vídeos da maneira acima aceita. `

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 a documentação indica ( link ), você pode usar o tipo de recurso do canal e a Lista de operações para obter todos os vídeos em um canal. Esta operação deve ser realizada usando o argumento 'channel id'.