YouTube-API zum Abrufen aller Videos auf einem Kanal

Wir benötigen eine Videoliste nach dem Kanalnamen von YouTube (unter Verwendung der API).

Wir können eine Kanalliste (nur Kanalname) erhalten, indem wir die folgende API verwenden:

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

Unten finden Sie einen direkten Link zu den Kanälen

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

Oder

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

Jetzt brauchen wir Videos von Kanal >> UCqAEtEr0A0Eo2IVcuWBfB9g oder HC-8jgBP-4rlI.

Wir haben es versucht

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

Aber es hilft nicht.

Wir brauchen alle Videos, die auf dem Kanal gepostet werden. Auf einen Kanal hochgeladene Videos können von mehreren Benutzern stammen, daher glaube ich nicht, dass die Bereitstellung eines Benutzerparameters hilfreich wäre ...

Sie müssen sich die YouTube-Daten-API ansehen . Dort finden Sie eine Dokumentation darüber, wie auf die API zugegriffen werden kann. Sie können auch Client-Bibliotheken finden .

Sie können die Anfragen auch selbst stellen. Hier ist eine Beispiel-URL, die die neuesten Videos von einem Kanal abruft:

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

Danach erhalten Sie eine JSONmit Video-IDs und Details, und Sie können Ihre Video-URL wie folgt erstellen:

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

Zunächst müssen Sie die ID der Wiedergabeliste abrufen, die die Uploads vom Benutzer / Kanal darstellt:

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

Sie können den Benutzernamen mit dem forUsername={username}Parameter angeben oder angeben mine=true, um Ihren eigenen zu erhalten (Sie müssen sich zuerst authentifizieren). Einschließen part=contentDetails, um die Wiedergabelisten anzuzeigen.

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

Das Ergebnis "relatedPlaylists"enthält "likes"und "uploads"Wiedergabelisten. Besorgen Sie sich die "upload"ID der Wiedergabeliste. Beachten "id"Sie auch, dass dies Ihre Kanal-ID ist, damit Sie später darauf zurückgreifen können.

Als nächstes erhalten Sie eine Liste der Videos in dieser Wiedergabeliste:

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

Einfach in die PlaylistId einfügen!

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

Hier ist ein Video von Google-Entwicklern, das zeigt, wie alle Videos in einem Kanal v3der YouTube-API aufgelistet werden.

Es gibt zwei Schritte:

1. Fragen Sie Kanäle ab, um die ID "Uploads" zu erhalten. z.Bhttps://www.googleapis.com/youtube/v3/channels?id={channel Id}&key={API key}&part=contentDetails

2. Verwenden Sie diese "Uploads" -ID, um PlaylistItems abzufragen und die Liste der Videos abzurufen. z.Bhttps://www.googleapis.com/youtube/v3/playlistItems?playlistId={"uploads" Id}&key={API key}&part=snippet&maxResults=50

So erhalten Sie eine Kanalliste:

Kanalliste mit forUserName abrufen :

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

Kanalliste nach Kanal-ID abrufen :

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

Kanalabschnitte abrufen:

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

So erhalten Sie Wiedergabelisten:

Holen Sie sich Wiedergabelisten nach Kanal-ID :

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

Holen Sie sich Wiedergabelisten nach Kanal-ID mit pageToken :

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

So erhalten Sie PlaylistItems:

Holen Sie sich die PlaylistItems-Liste von PlayListId :

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

So erhalten Sie Videos:

Video- Liste nach Video-ID abrufen :

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

Holen Sie sich die Liste der Videos nach mehreren Videos ID :

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

Erhalten Kommentarliste

Kommentarliste per Video-ID abrufen :

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

Kommentarliste nach Kanal-ID abrufen :

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

Kommentarliste von allThreadsRelatedToChannelId abrufen :

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

Hier sind alle APIs Get Ansatz.

Basierend auf der Kanal-ID erhalten wir nicht alle Videos direkt, das ist hier der wichtige Punkt.

Zur Integration https://developers.google.com/youtube/v3/quickstart/ios?ver=swift

Unten finden Sie eine Python-Alternative, für die keine speziellen Pakete erforderlich sind. Durch Angabe der Kanal-ID wird eine Liste der Videolinks für diesen Kanal zurückgegeben. Bitte beachten Sie, dass Sie einen API-Schlüssel benötigen , damit dies funktioniert.

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

Hier ist der Code, der alle Video-IDs unter Ihrem Kanal zurückgibt

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

Hinweis : Sie können die Kanal-ID nach dem Anmelden unter https://www.youtube.com/account_advanced abrufen.

Versuchen Sie es wie folgt. Es kann Ihnen helfen.

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

Hier können Sie als Autor Ihren Kanalnamen und "q" als Suchschlüssel angeben.

Nur in drei Schritten:

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

2. Kanäle: 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}

Dank der hier und anderswo geteilten Referenzen habe ich ein Online-Skript / Tool erstellt, mit dem alle Videos eines Kanals abgerufen werden können.

Es kombiniert API - Aufrufe youtube.channels.list, playlistItems, videos. Es verwendet rekursive Funktionen, damit die asynchronen Rückrufe die nächste Iteration ausführen, sobald eine gültige Antwort erhalten wird.

Dies dient auch dazu, die tatsächliche Anzahl der gleichzeitig gestellten Anfragen zu begrenzen und dich so vor Verstößen gegen die YouTube-API-Regeln zu schützen. Teilen Sie verkürzte Snippets und dann einen Link zum vollständigen Code. Ich habe die maximale Anzahl von 50 Ergebnissen pro Anruf erreicht, indem ich den nextPageToken-Wert verwendet habe, der in der Antwort zum Abrufen der nächsten 50 Ergebnisse usw. enthalten ist.

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

Dies führte zu einer grundlegenden Auflistung der Videos, einschließlich ID, Titel, Veröffentlichungsdatum und ähnlichem. Um jedoch detailliertere Informationen zu den einzelnen Videos zu erhalten, z. B. Anzahl und Likes der Ansicht, müssen API-Aufrufe durchgeführt werden 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.
            }
});

Den vollständigen Code finden Sie hier und die Live-Version hier . (Bearbeiten: fester Github-Link)
Bearbeiten: Abhängigkeiten: JQuery, Papa.parse

Da jeder, der diese Frage beantwortet, aufgrund des Limits von 500 Videos Probleme hat , gibt es hier eine alternative Lösung mit youtube_dl in Python 3 . Außerdem wird kein API-Schlüssel benötigt .

1. Installiere youtube_dl: sudo pip3 install youtube-dl
2. Finden Sie die Kanal-ID Ihres Zielkanals heraus . Die ID beginnt mit UC. Ersetzen Sie das C für Kanal durch U für Upload (dh UU ...). Dies ist die Upload-Wiedergabeliste .
3. Verwenden Sie die Downloader-Funktion für Wiedergabelisten von youtube-dl. Idealerweise möchten Sie NICHT jedes Video in der Wiedergabeliste herunterladen, das die Standardeinstellung ist, sondern nur die Metadaten.

Beispiel (Warnung - dauert mehrere zehn Minuten):

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

Unter Verwendung der veralteten API-Version 2 lautet die URL für Uploads (des Kanals UCqAEtEr0A0Eo2IVcuWBfB9g):

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

Es gibt eine API-Version 3.

Vor kurzem musste ich alle Videos von einem Kanal abrufen und laut YouTube-Entwicklerdokumentation: 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'));

Wo $serviceist dein Google_Service_YouTubeObjekt?

Sie müssen also Informationen aus dem Kanal abrufen, um die Wiedergabeliste "Uploads" abzurufen, in der alle vom Kanal hochgeladenen Videos enthalten sind: https://developers.google.com/youtube/v3/docs/channels/list

Wenn diese API neu ist, empfehle ich dringend, das Codebeispiel vom Standard-Snippet in das vollständige Beispiel umzuwandeln.

Der grundlegende Code zum Abrufen aller Videos von einem Kanal kann also sein:

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

Beispiellösung in Python. Hilfe aus diesem Video: Video Wie bei vielen anderen Antworten muss die Upload-ID zuerst von der Kanal-ID abgerufen werden.

importiere urllib.request
json importieren

key = "YOUR_YOUTUBE_API_v3_BROWSER_KEY"

#Liste der Kanäle: Geben Sie an, ob Sie die Kanal-ID oder den Benutzernamen einfügen - "id" oder "forUsername".
ytids = [["bbcnews", "forUsername"], ["UCjq4pjKj9X4W9i7UnYShpVg", "id"]]

newstitles = []
für ytid ytparam in ytids:
    urld = "https://www.googleapis.com/youtube/v3/channels?part=contentDetails&"+ytparam+"="+ytid+"&key="+key
    mit urllib.request.urlopen (urld) als URL:
        datad = json.loads (url.read ())
    uploadsdet = datad ['items']
    #get Upload-ID von Kanal-ID
    uploadid = uploadsdet [0] ['contentDetails'] ['relatedPlaylists'] ['uploads']

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

    für Daten in datad ['items']:
        ntitle = data ['snippet'] ['title']
        nlink = data ['contentDetails'] ['videoId']
        newstitles.append ([nlink, ntitle])

für Link, Titel in Newstitles:
    Drucken (Link, Titel)

Vom YouTube-Kanal heruntergeladene Links, Verzeichnisstruktur nicht beibehalten. Also habe ich einen Code geschrieben, um dies zu ermöglichen. Verwenden Sie diese Option, sobald Sie die Videos von der oben akzeptierten Weise heruntergeladen haben. `

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

`

Wie in der Dokumentation angegeben ( Link ), können Sie den Ressourcentyp und die Operationsliste des Kanals verwenden, um alle Videos in einem Kanal abzurufen. Diese Operation muss mit dem Argument 'Kanal-ID' ausgeführt werden.