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 ...
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}
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}
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:
- Abfrage-Channels, um die "Uploads" -ID zu erhalten. zB
https://www.googleapis.com/youtube/v3/channels?id={channel Id}&key={API key}&part=contentDetails - 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
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.
Kanalliste abrufen:
Kanalliste abrufen mit forUserName :
Kanalliste abrufen nach Kanal-ID :
Channel-Abschnitte abrufen:
So rufen Sie Wiedergabelisten ab:
Abrufen von Wiedergabelisten nach Kanal-ID :
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 :
Um Videos zu bekommen:
Videoliste abrufen nach Video-ID :
Videoliste abrufen mit ID mehrerer Videos :
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
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
Nur in drei Schritten:
Abonnements: list -> https://www.googleapis.com/youtube/v3/subscriptions?part=snippet&maxResults=50&mine=true&access_token= {oauth_token}
Channels: list -> https://www.googleapis.com/youtube/v3/channels?part=contentDetails&id= {channel_id} & key = {YOUR_API_KEY}
PlaylistItems: list -> https://www.googleapis.com/youtube/v3/playlistItems?part=snippet&playlistId= {playlist_id} & key = {YOUR_API_KEY}
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)
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.
- Installiere youtube_dl:
Sudo pip3 install youtube-dl - 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.
- 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))
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.
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.
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)
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>';
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])
`