API di YouTube per recuperare tutti i video su un canale

Abbiamo bisogno di un elenco di video per nome del canale di YouTube (utilizzando l'API).

È possibile ottenere un elenco di canali (solo nome del canale) utilizzando l'API di seguito:

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

Di seguito è riportato un collegamento diretto di canali

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

O

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

Ora, abbiamo bisogno dei video del canale >> UCqAEtEr0A0Eo2IVcuWBfB9g o HC-8jgBP-4rlI.

Abbiamo provato

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

Ma non aiuta.

Abbiamo bisogno di tutti i video pubblicati sul canale. I video caricati su un canale possono provenire da più utenti, quindi non credo che fornire un parametro utente possa aiutare ...

Devi guardare l' API dei dati di YouTube . Troverai la documentazione su come accedere all'API. È inoltre possibile trovare librerie client .

Puoi anche effettuare le richieste tu stesso. Ecco un URL di esempio che recupera gli ultimi video da un canale:

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

Dopodiché riceverai un JSONcon ID video e dettagli e puoi costruire l'URL del tuo video in questo modo:

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

Innanzitutto, devi ottenere l'ID della playlist che rappresenta i caricamenti dall'utente / canale:

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

È possibile specificare il nome utente con il forUsername={username}parametro o specificare mine=trueper ottenerne uno proprio (è necessario prima autenticarsi). Includi part=contentDetailsper vedere le playlist.

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

Nel risultato "relatedPlaylists"includeranno "likes"e "uploads"playlist. Prendi l' "upload"ID della playlist. Nota anche che "id"è il tuo channelID per riferimento futuro.

Quindi, ottieni un elenco di video in quella playlist:

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

Inserisci la playlistId!

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

Ecco un video di Google Developers che mostra come elencare tutti i video in un canale v3nell'API di YouTube.

Ci sono due passaggi:

1. Canali di query per ottenere l'ID "uploads". per esempiohttps://www.googleapis.com/youtube/v3/channels?id={channel Id}&key={API key}&part=contentDetails

2. Usa questo ID "uploads" per eseguire una query su PlaylistItems per ottenere l'elenco dei video. per esempiohttps://www.googleapis.com/youtube/v3/playlistItems?playlistId={"uploads" Id}&key={API key}&part=snippet&maxResults=50

Per ottenere l'elenco dei canali:

Ottieni l'elenco dei canali per nome utente :

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

Ottieni l'elenco dei canali per ID canale :

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

Ottieni sezioni del canale:

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

Per ottenere playlist:

Ottieni playlist per ID canale :

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

Ottieni playlist per ID canale con pageToken :

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

Per ottenere PlaylistItems:

Ottieni l'elenco PlaylistItems da PlayListId :

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

Per ottenere video:

Ottieni l'elenco dei video per ID video :

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

Ottieni l'elenco dei video per più ID video :

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

Ottieni l' elenco dei commenti

Ottieni l'elenco dei commenti per ID video :

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

Ottieni l'elenco dei commenti per ID canale :

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

Ottieni l'elenco dei commenti da allThreadsRelatedToChannelId :

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

Qui tutti gli API sono l' approccio Get .

In base all'ID del canale non otteniamo tutti i video direttamente, questo è il punto importante qui.

Per l'integrazione https://developers.google.com/youtube/v3/quickstart/ios?ver=swift

Di seguito è un'alternativa a Python che non richiede pacchetti speciali. Fornendo l'ID canale restituisce un elenco di collegamenti video per quel canale. Si noti che è necessaria una chiave API per funzionare.

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

Ecco il codice che restituirà tutti gli ID video sotto il tuo canale

<?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 : puoi ottenere l'ID canale su https://www.youtube.com/account_advanced dopo aver effettuato l'accesso.

Prova con il seguente. Potrebbe esserti d'aiuto.

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

Qui autore come puoi specificare il nome del tuo canale e "q" come puoi dare la parola chiave di ricerca.

Solo in tre passaggi:

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

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

Grazie ai riferimenti condivisi qui e altrove, ho realizzato uno script / strumento online che è possibile utilizzare per ottenere tutti i video di un canale.

Esso combina chiamate API a youtube.channels.list, playlistItems, videos. Utilizza funzioni ricorsive per fare in modo che i callback asincroni eseguano la successiva iterazione dopo aver ottenuto una risposta valida.

Ciò serve anche a limitare il numero effettivo di richieste fatte contemporaneamente, proteggendoti quindi dalla violazione delle regole dell'API di YouTube. Condivisione di snippet abbreviati e quindi un collegamento al codice completo. Ho ottenuto circa il limite massimo di 50 risultati per chiamata utilizzando il valore nextPageToken fornito nella risposta per recuperare i successivi 50 risultati e così via.

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

Questo ha un elenco di base dei video, tra cui ID, titolo, data di pubblicazione e simili. Ma per ottenere maggiori dettagli di ogni video come conteggi e Mi piace delle visualizzazioni, è necessario effettuare chiamate 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.
            }
});

Vedi il codice completo qui e la versione live qui . (Modifica: collegamento github fisso)
Modifica: dipendenze: JQuery, Papa.parse

Poiché tutti coloro che rispondono a questa domanda hanno problemi a causa del limite di 500 video, ecco una soluzione alternativa che utilizza youtube_dl in Python 3 . Inoltre, non è necessaria alcuna chiave API .

1. Installa youtube_dl: sudo pip3 install youtube-dl
2. Scopri l'ID canale del tuo canale target . L'ID inizierà con UC. Sostituisci C per canale con U per caricamento (ovvero UU ...), questa è la playlist di caricamento .
3. Utilizzare la funzione di download della playlist da youtube-dl. Idealmente NON vuoi scaricare tutti i video nella playlist che è l'impostazione predefinita, ma solo i metadati.

Esempio (avviso - richiede decine di minuti):

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

Utilizzando l'API versione 2, che è obsoleta, l'URL per i caricamenti (del canale UCqAEtEr0A0Eo2IVcuWBfB9g) è:

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

Esiste una versione API 3.

Recentemente ho dovuto recuperare tutti i video da un canale e, secondo la documentazione per gli sviluppatori di 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'));

Dov'è il $servicetuo Google_Service_YouTubeoggetto.

Quindi devi recuperare informazioni dal canale per recuperare la playlist "uploads" che in realtà ha tutti i video caricati dal canale: https://developers.google.com/youtube/v3/docs/channels/list

Se nuovo con questa API, consiglio vivamente di convertire l'esempio di codice dallo snippet predefinito all'esempio completo.

Quindi il codice di base per recuperare tutti i video da un canale può essere:

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

Soluzione di esempio in Python. Aiuto tratto da questo video: video Come molte altre risposte, l'ID di caricamento deve prima essere recuperato dall'ID del canale.

import urllib.request
import json

key = "YOUR_YOUTUBE_API_v3_BROWSER_KEY"

# Elenco dei canali: menziona se stai incollando ID canale o nome utente - "ID" o "per Nome utente"
ytids = [["" bbcnews "," forUsername "], [" UCjq4pjKj9X4W9i7UnYShpVg "," id "]]

newstitles = []
per ytid, ytparam in ytids:
    urld = "https://www.googleapis.com/youtube/v3/channels?part=contentDetails&"+ytparam+"="+ytid+"&key="+key
    con urllib.request.urlopen (urld) come url:
        datad = json.loads (url.read ())
    uploadsdet = datad ['items']
    #get carica ID dall'ID canale
    uploadid = uploadsdet [0] ['contentDetails'] ['relatedPlaylists'] ['uploads']

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

    per i dati nel datad ['items']:
        ntitle = data ['snippet'] ['title']
        nlink = data ['contentDetails'] ['videoId']
        newstitles.append ([nlink, ntitle])

per link, titolo in newstitles:
    stampa (link, titolo)

Link scaricati dal canale YouTube, non struttura della directory del Preserver. Quindi, ho scritto un codice per farlo accadere. Usalo dopo aver scaricato i video dal modo sopra accettato. `

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

`

Come indicato nella documentazione ( collegamento ), è possibile utilizzare il tipo di risorsa del canale e l'elenco operazioni per ottenere tutti i video in un canale. Questa operazione deve essere eseguita utilizzando l'argomento "ID canale".