it-swarm.com.de

YouTube-API zum Abrufen aller Videos auf einem Kanal

Wir benötigen eine Videoliste nach Kanalnamen von YouTube (über die API).

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

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

Unten ist eine direkte Verbindung von Kanälen

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

Oder

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

Nun brauchen wir Videos des Kanals >> UCqAEtEr0A0Eo2IVcuWBfB9g oder HC-8jgBP-4rlI.

Wir haben es versucht

https://gdata.youtube.com/feeds/api/videos?v=2&uploader=partner&User=UC7Xayrf2k0NZiz3S04WuDNQhttps://gdata.youtube.com/feeds/api/videos?v=2&uploader=partner&q=UC7Xayrf2k0NZiz3S04WuDNQ

Aber es hilft nicht.

Wir brauchen alle Videos, die auf dem Kanal gepostet werden. Videos, die auf einen Kanal hochgeladen werden, können von mehreren Benutzern stammen. Ich denke nicht, dass die Angabe eines Benutzerparameters hilfreich wäre ...

133
Rajendra Dewani

Sie müssen sich die YouTube Data API ansehen. Dort finden Sie Dokumentation, 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 JSON mit Video-IDs und Details, und Sie können Ihre Video-URL folgendermaßen erstellen:

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

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

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

Sie können den Benutzernamen mit forUsername={username} param angeben oder mine=true angeben, um Ihren eigenen Namen zu erhalten (Sie müssen sich zuerst authentifizieren). Fügen Sie part=contentDetails hinzu, um die Wiedergabelisten anzuzeigen.

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

Im Ergebnis enthält "relatedPlaylists" Wiedergabelisten "likes" und "uploads". Holen Sie sich diese "upload"-Wiedergabelisten-ID. Beachten Sie auch, dass "id" Ihre ChannelID zur späteren Bezugnahme ist. 

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 fallen!

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

78
jambrose

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

Es gibt zwei Schritte:

  1. Abfrage-Channels, um die "Uploads" -ID zu erhalten. zB https://www.googleapis.com/youtube/v3/channels?id={channel Id}&key={API key}&part=contentDetails
  2. Verwenden Sie diese "Uploads" -ID, um PlaylistItems abzufragen, um die Liste der Videos abzurufen. zB https://www.googleapis.com/youtube/v3/playlistItems?playlistId={"uploads" Id}&key={API key}&part=snippet&maxResults=50
47
virtualmic

Versuchen Sie es mit dem folgenden. Es kann dir helfen.

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

Als Autor können Sie hier Ihren Kanalnamen angeben und "q", wenn Sie Ihrem Suchschlüssel das Wort "Word" geben.

7
Nagaraja

Kanalliste abrufen:

Kanalliste abrufen mit forUserName :

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

Kanalliste abrufen nach Kanal-ID :

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

Channel-Abschnitte abrufen:

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

So rufen Sie Wiedergabelisten ab:

Abrufen von Wiedergabelisten nach Kanal-ID :

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

Erhalte Wiedergabelisten von Kanal-ID mit pageToken :

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

Um PlaylistItems zu erhalten:

Abrufen der PlaylistItems-Liste mit PlayListId :

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

Um Videos zu bekommen:

Videoliste abrufen nach Video-ID :

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

Videoliste abrufen mit ID mehrerer Videos :

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

Holen Sie sich Kommentarliste

Kommentarliste abrufen nach Video-ID :

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

Kommentarliste abrufen nach Kanal-ID :

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

Kommentarliste abrufen von allThreadsRelatedToChannelId :

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

Hier sind alle APIs Get Ansatz.

Aufgrund der Kanal-ID werden nicht alle Videos direkt abgerufen, das ist hier der wichtige Punkt.

Für die Integration https://developers.google.com/youtube/v3/quickstart/ios?ver=Swift

7
iOS

Nachfolgend finden Sie eine Python-Alternative, für die keine speziellen Pakete erforderlich sind. Durch die Angabe der Kanal-ID wird eine Liste von Videolinks für diesen Kanal zurückgegeben. Bitte beachten Sie, dass Sie einen API Key benötigen, damit er 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
7
Stian

Nur in drei Schritten:

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

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

4
sacred

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

Es kombiniert API-Aufrufe zu youtube.channels.list, playlistItems, videos. Es verwendet rekursive Funktionen, damit die asynchronen Callbacks die nächste Iteration ausführen, wenn sie eine gültige Antwort erhalten.

Dies dient auch dazu, die tatsächliche Anzahl der gleichzeitig gestellten Anfragen zu begrenzen und Sie so vor einem Verstoß gegen die Regeln der YouTube-API zu schützen. Verkürzte Ausschnitte teilen und dann einen Link zum vollständigen Code. Ich bin um die Begrenzung der maximal 50 Ergebnisse pro Aufruf herumgekommen, indem ich den nextPageToken-Wert verwendet habe, der in der Antwort zum Abrufen der nächsten 50 Ergebnisse usw. angezeigt wird.

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

Diese Liste enthält eine grundlegende Auflistung der Videos, einschließlich ID, Titel, Veröffentlichungsdatum und ähnliches. Um jedoch mehr Details zu jedem Video wie Ansichtszählungen und Vorlieben zu erhalten, müssen API-Aufrufe an videos ausgeführt werden.

// 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 Live-Version hier . (Bearbeiten: fester Github-Link)

4
Nikhil VJ

Da jeder, der diese Frage beantwortet, Probleme mit dem 500-Videolimit hat, ist hier eine alternative Lösung, die youtube_dl in Python 3 verwendet. Außerdem ist kein API-Schlüssel erforderlich.

  1. Installiere youtube_dl: Sudo pip3 install youtube-dl
  2. Finden Sie die Kanal-ID Ihres Zielkanals heraus . Die ID wird mit UC beginnen. Ersetzen Sie C für Channel durch U für Upload (d. H. UU ...). Dies ist die upload-Wiedergabeliste.
  3. Verwenden Sie die Funktion playlist downloader von youtube-dl. Idealerweise möchten Sie NICHT alle Videos in der Wiedergabeliste (Standardeinstellung) herunterladen, sondern nur die Metadaten.

Beispiel (Warnung - dauert 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))
3
xjcl

Bei 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.

2
Als

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

Note: Die Kanal-ID kann unter .__ abgerufen werden. https://www.youtube.com/account_advanced nach dem Einloggen.

2
Mihir Bhatt

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

 import urllib.request 
 import json 
 
 key = "YOUR_YOUTUBE_API_v3_BROWSER_KEY" 
 
 # Liste der Kanäle: Geben Sie an, ob Sie es sind Einfügen der Kanal-ID oder des Benutzernamens - "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 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
 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 den Link, Titel in newstitles: 
 drucken (Link, Titel) 
1
Ananth

Vor kurzem musste ich alle Videos von einem Kanal abrufen. 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'));

Wobei $service Ihr Google_Service_YouTube-Objekt ist.

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

Wenn es sich um ein neues API handelt, empfehle ich dringend, das Codebeispiel vom Standard-Snippet auf das vollständige Beispiel umzustellen.

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

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

Vom YouTube-Kanal heruntergeladene Links, Verzeichnisstruktur nicht beibehalten. Also habe ich einen Code geschrieben, der das möglich macht. Verwenden Sie diese Option, sobald Sie die Videos auf die oben angegebene 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])

`

0
shivam13juna