YouTube API do pobierania wszystkich filmów na kanale

Potrzebujemy listy filmów według nazwy kanału YouTube (przy użyciu interfejsu API).

Możemy uzyskać listę kanałów (tylko nazwa kanału), używając poniższego interfejsu API:

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

Poniżej znajduje się bezpośredni link do kanałów

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

Lub

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

Teraz potrzebujemy filmów z kanału >> UCqAEtEr0A0Eo2IVcuWBfB9g lub HC-8jgBP-4rlI.

Próbowaliśmy

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

Ale to nie pomaga.

Potrzebujemy wszystkich filmów opublikowanych na kanale. Filmy przesłane do kanału mogą pochodzić od wielu użytkowników, więc nie sądzę, aby podanie parametru użytkownika pomogło ...

Musisz spojrzeć na interfejs YouTube Data API . Znajdziesz tam dokumentację dotyczącą sposobu dostępu do API. Możesz także znaleźć biblioteki klienta .

Możesz również sam złożyć prośby. Oto przykładowy adres URL, który pobiera najnowsze filmy z kanału:

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

Następnie otrzymasz JSONidentyfikatory wideo i szczegóły oraz możesz skonstruować swój adres URL wideo w następujący sposób:

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

Najpierw musisz uzyskać identyfikator listy odtwarzania reprezentującej przesłane przez użytkownika / kanał:

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

Możesz podać nazwę użytkownika za pomocą forUsername={username}parametru lub określić, mine=trueaby uzyskać własną (musisz najpierw uwierzytelnić). Dołącz, part=contentDetailsaby zobaczyć listy odtwarzania.

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

W rezultacie "relatedPlaylists"zostaną uwzględnione "likes"i "uploads"listy odtwarzania. Chwyć ten "upload"identyfikator listy odtwarzania. Zwróć także uwagę, że "id"jest to identyfikator Twojego kanału na wypadek, gdyby okazało się, że będziesz w przyszłości.

Następnie uzyskaj listę filmów na tej liście odtwarzania:

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

Po prostu dodaj listę odtwarzania!

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

Oto film od programistów Google pokazujący, jak wyświetlić listę wszystkich filmów na kanale w v3interfejsie API YouTube.

Istnieją dwa kroki:

1. Zapytaj kanały, aby uzyskać identyfikator „przesłane”. na przykładhttps://www.googleapis.com/youtube/v3/channels?id={channel Id}&key={API key}&part=contentDetails

2. Użyj tego „przesłanego” identyfikatora, aby wyszukać PlaylistItems w celu uzyskania listy filmów. na przykładhttps://www.googleapis.com/youtube/v3/playlistItems?playlistId={"uploads" Id}&key={API key}&part=snippet&maxResults=50

Aby uzyskać listę kanałów:

Pobierz listę kanałów według forUserName :

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

Pobierz listę kanałów według identyfikatora kanału :

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

Uzyskaj sekcje kanału:

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

Aby uzyskać listy odtwarzania:

Pobierz listy odtwarzania według identyfikatora kanału :

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

Pobierz listy odtwarzania według identyfikatora kanału za pomocą pageToken :

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

Aby uzyskać PlaylistItems:

Pobierz listę PlaylistItems od PlayListId :

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

Aby uzyskać filmy:

Pobierz listę filmów według identyfikatora wideo :

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

Pobierz listę filmów według identyfikatora wielu filmów :

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

Uzyskaj listę komentarzy

Uzyskaj listę komentarzy według identyfikatora wideo :

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

Uzyskaj listę komentarzy według identyfikatora kanału :

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

Uzyskaj listę komentarzy od allThreadsRelatedToChannelId :

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

Tutaj wszystkie api mają podejście Get .

Na podstawie identyfikatora kanału nie otrzymujemy wszystkich filmów bezpośrednio, to jest tutaj ważny punkt.

Do integracji https://developers.google.com/youtube/v3/quickstart/ios?ver=swift

Poniżej znajduje się alternatywa dla Pythona, która nie wymaga żadnych specjalnych pakietów. Podając identyfikator kanału, zwraca listę linków wideo dla tego kanału. Pamiętaj, że potrzebujesz klucza API , aby działał.

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

Oto kod, który zwróci wszystkie identyfikatory filmów na Twoim kanale

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

Uwaga : identyfikator kanału można uzyskać na stronie https://www.youtube.com/account_advanced po zalogowaniu.

Spróbuj wykonać następujące czynności. To może ci pomóc.

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

Tutaj autor, ponieważ możesz podać nazwę kanału i „q”, ponieważ możesz podać słowo kluczowe wyszukiwania.

Tylko w trzech krokach:

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

2. Kanały: 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}

Dzięki referencjom udostępnionym tutaj i gdzie indziej stworzyłem skrypt online / narzędzie, którego można użyć do uzyskania wszystkich filmów z kanału.

Łączy wywołań API do youtube.channels.list, playlistItems, videos. Używa funkcji rekurencyjnych, aby asynchroniczne wywołania zwrotne uruchamiały następną iterację po otrzymaniu poprawnej odpowiedzi.

Służy to również ograniczeniu faktycznej liczby żądań wysyłanych jednocześnie, tym samym chroniąc Cię przed naruszeniem reguł API YouTube. Udostępnianie skróconych fragmentów, a następnie link do pełnego kodu. Osiągnąłem około 50 maksymalnych wyników na ograniczenie połączenia, używając wartości nextPageToken, która pojawia się w odpowiedzi na pobranie następnych 50 wyników i tak dalej.

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

Otrzymało to podstawową listę filmów, w tym identyfikator, tytuł, datę publikacji i podobne. Ale aby uzyskać więcej szczegółów na temat każdego filmu, takich jak liczba wyświetleń i polubienia, należy wykonać wywołania 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.
            }
});

Zobacz pełny kod tutaj , a wersję na żywo tutaj . (Edycja: naprawiono link github)
Edycja: Zależności: JQuery, Papa.parse

Ponieważ każdy, kto odpowiada na to pytanie, ma problemy z powodu limitu 500 filmów, oto alternatywne rozwiązanie, używając youtube_dl w Pythonie 3 . Ponadto nie jest wymagany klucz API .

1. Zainstaluj youtube_dl: sudo pip3 install youtube-dl
2. Znajdź identyfikator kanału docelowego . Identyfikator zacznie się od UC. Zamień C dla kanału na U dla przesyłania (tj. UU ...), to jest lista odtwarzania przesyłania .
3. Skorzystaj z funkcji pobierania listy odtwarzania z youtube-dl. W idealnym przypadku NIE chcesz pobierać wszystkich filmów z listy odtwarzania, która jest domyślna, ale tylko metadane.

Przykład (ostrzeżenie - trwa kilkadziesiąt minut):

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

Przy użyciu nieaktualnego interfejsu API w wersji 2 adres URL przesyłania (kanału UCqAEtEr0A0Eo2IVcuWBfB9g) to:

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

Istnieje wersja API 3.

Ostatnio musiałem pobrać wszystkie filmy z kanału i zgodnie z dokumentacją dla programistów 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'));

Gdzie $servicejest twójGoogle_Service_YouTube przedmiot?

Musisz więc pobrać informacje z kanału, aby pobrać listę odtwarzania „przesyłane”, która faktycznie zawiera wszystkie filmy przesłane przez kanał: https://developers.google.com/youtube/v3/docs/channels/list

Jeśli nowy z tym interfejsem API, jest wysoce zalecany, aby zmienić przykładowy kod z domyślnego fragmentu kodu na pełny przykład.

Podstawowym kodem do pobierania wszystkich filmów z kanału może być:

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

Przykładowe rozwiązanie w Pythonie. Pomoc zaczerpnięta z tego filmu: wideo Podobnie jak wiele innych odpowiedzi, identyfikator przesyłania należy najpierw pobrać z identyfikatora kanału.

import urllib.request
import json

key = „YOUR_YOUTUBE_API_v3_BROWSER_KEY”

# Lista kanałów: podaj, jeśli wklejasz identyfikator kanału lub nazwę użytkownika - „id” lub „forUsername”
ytids = [[„bbcnews”, „forUsername”], [„UCjq4pjKj9X4W9i7UnYShpVg”, „id”]]

newstitles = []
dla ytid, ytparam in ytids:
    urld = "https://www.googleapis.com/youtube/v3/channels?part=contentDetails&"+ytparam+"="+ytid+"&key="+key
    z urllib.request.urlopen (urld) jako URL:
        datad = json.loads (url.read ())
    uploadsdet = datad ['items']
    #get przesłać identyfikator z identyfikatora kanału
    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
    z urllib.request.urlopen (urld) jako URL:
        datad = json.loads (url.read ())

    dla danych w datad [„przedmioty”]:
        ntitle = data ['snippet'] ['title']
        nlink = data ['contentDetails'] ['videoId']
        newstitles.append ([nlink, ntitle])

dla linku tytuł w nowych tytułach:
    drukuj (link, tytuł)

Linki pobrane z kanału youtube, nie zachowuj struktury katalogów. Więc napisałem kod, aby to się stało. Użyj tego po pobraniu filmów z wyżej zaakceptowanego sposobu. `

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

`

Jak stwierdza dokumentacja ( link ), możesz użyć typu zasobu kanału i listy operacji, aby uzyskać wszystkie filmy w kanale. Tę operację należy wykonać przy użyciu argumentu „identyfikator kanału”.