Gibt eine Sammlung von Playlist-Elementen zurück, die den API-Anfrageparametern entsprechen. Du kannst alle Playlist-Elemente in einer bestimmten Playlist oder ein oder mehrere Playlist-Elemente anhand ihrer eindeutigen IDs abrufen.
Auswirkungen auf Kontingente:Bei einem Aufruf dieser Methode fallen Kontingentkosten von 1 Einheit an.
Gängige Anwendungsfälle
Anfragen
HTTP-Anfrage
GET https://www.googleapis.com/youtube/v3/playlistItems
Parameter
In der folgenden Tabelle sind die Parameter aufgeführt, die von dieser Abfrage unterstützt werden. Alle aufgeführten Parameter sind Abfrageparameter.
Parameter | ||
---|---|---|
Erforderliche Parameter | ||
part |
string Der Parameter part gibt eine durch Kommas getrennte Liste mit einer oder mehreren playlistItem -Ressourceneigenschaften an, die in der API-Antwort enthalten sein werden.Wenn der Parameter eine Property mit untergeordneten Properties angibt, werden die untergeordneten Properties in die Antwort aufgenommen. In einer playlistItem -Ressource enthält die Property snippet beispielsweise zahlreiche Felder, darunter die Attribute title , description , position und resourceId . Wenn Sie part=snippet festlegen, enthält die API-Antwort daher alle diese Attribute.Die folgende Liste enthält die part -Namen, die Sie in den Parameterwert aufnehmen können:
|
|
Filter (genau einen der folgenden Parameter angeben) | ||
id |
string Der Parameter id gibt eine durch Kommas getrennte Liste mit einer oder mehreren eindeutigen Playlist-Element-IDs an. |
|
playlistId |
string Der Parameter playlistId gibt die eindeutige ID der Playlist an, für die du Playlist-Elemente abrufen möchtest. Obwohl dies ein optionaler Parameter ist, muss in jeder Anfrage zum Abrufen von Playlist-Elementen ein Wert für den Parameter id oder playlistId angegeben werden. |
|
Optionale Parameter | ||
maxResults |
unsigned integer Der Parameter maxResults gibt die maximale Anzahl von Elementen an, die in der Ergebnismenge zurückgegeben werden sollen. Zulässige Werte sind 0 bis 50 . Der Standardwert ist 5 . |
|
onBehalfOfContentOwner |
string Dieser Parameter kann nur in einer ordnungsgemäß autorisierten Anfrage verwendet werden. Hinweis: Dieser Parameter ist ausschließlich für YouTube-Content-Partner vorgesehen. Der Parameter onBehalfOfContentOwner gibt an, dass die Autorisierungsanmeldedaten der Anfrage einen YouTube CMS-Nutzer identifizieren, der im Namen des im Parameterwert angegebenen Rechteinhabers handelt. Dieser Parameter ist für YouTube-Content-Partner vorgesehen, die viele verschiedene YouTube-Kanäle besitzen und verwalten. Rechteinhaber können sich einmalig authentifizieren und auf alle ihre Video- und Kanaldaten zugreifen, ohne für jeden einzelnen Kanal Anmeldedaten zur Authentifizierung angeben zu müssen. Das CMS-Konto, mit dem sich der Nutzer authentifiziert, muss mit dem angegebenen YouTube-Rechteinhaber verknüpft sein. |
|
pageToken |
string Der Parameter pageToken gibt eine bestimmte Seite im Ergebnissatz an, die zurückgegeben werden soll. In einer API-Antwort identifizieren die Attribute nextPageToken und prevPageToken andere Seiten, die abgerufen werden können. |
|
videoId |
string Der Parameter videoId gibt an, dass die Anfrage nur die Elemente der Playlist zurückgeben soll, die das angegebene Video enthalten. |
Anfragetext
Geben Sie beim Aufrufen dieser Methode keinen Anfragetext an.
Antwort
Bei Erfolg gibt diese Methode einen Antworttext mit der folgenden Struktur zurück:
{ "kind": "youtube#playlistItemListResponse", "etag": etag, "nextPageToken": string, "prevPageToken": string, "pageInfo": { "totalResults": integer, "resultsPerPage": integer }, "items": [ playlistItem Resource ] }
Attribute
In der folgenden Tabelle werden die Attribute definiert, die in dieser Ressource angezeigt werden:
Attribute | |
---|---|
kind |
string Identifiziert den Typ der API-Ressource. Der Wert ist youtube#playlistItemListResponse . |
etag |
etag Das ETag dieser Ressource. |
nextPageToken |
string Das Token, das als Wert des Parameters pageToken verwendet werden kann, um die nächste Seite im Ergebnissatz abzurufen. |
prevPageToken |
string Das Token, das als Wert des Parameters pageToken verwendet werden kann, um die vorherige Seite im Ergebnissatz abzurufen. |
pageInfo |
object Das pageInfo -Objekt enthält Seiteninformationen für die Ergebnismenge. |
pageInfo.totalResults |
integer Die Gesamtzahl der Ergebnisse in der Ergebnismenge. |
pageInfo.resultsPerPage |
integer Die Anzahl der Ergebnisse, die in der API-Antwort enthalten sind. |
items[] |
list Eine Liste von Playlist-Elementen, die den Anfragekriterien entsprechen. |
Beispiele
Hinweis: Die folgenden Codebeispiele stehen möglicherweise nicht für alle unterstützten Programmiersprachen zur Verfügung. Eine Liste der unterstützten Sprachen finden Sie in der Dokumentation zu Clientbibliotheken.
Einfach loslegen (Go)
In diesem Codebeispiel wird die MethodeplaylistItems.list
der API aufgerufen, um eine Liste der Videos abzurufen, die auf den mit der Anfrage verknüpften Kanal hochgeladen wurden. Der Code ruft auch die Methode channels.list
auf, wobei der Parameter mine
auf true
gesetzt ist, um die Playlist-ID abzurufen, mit der die hochgeladenen Videos des Kanals identifiziert werden.
In diesem Beispiel wird die Go-Clientbibliothek verwendet.
package main import ( "fmt" "log" "google.golang.org/api/youtube/v3" ) // Retrieve playlistItems in the specified playlist func playlistItemsList(service *youtube.Service, part string, playlistId string, pageToken string) *youtube.PlaylistItemListResponse { call := service.PlaylistItems.List(part) call = call.PlaylistId(playlistId) if pageToken != "" { call = call.PageToken(pageToken) } response, err := call.Do() handleError(err, "") return response } // Retrieve resource for the authenticated user's channel func channelsListMine(service *youtube.Service, part string) *youtube.ChannelListResponse { call := service.Channels.List(part) call = call.Mine(true) response, err := call.Do() handleError(err, "") return response } func main() { client := getClient(youtube.YoutubeReadonlyScope) service, err := youtube.New(client) if err != nil { log.Fatalf("Error creating YouTube client: %v", err) } response := channelsListMine(service, "contentDetails") for _, channel := range response.Items { playlistId := channel.ContentDetails.RelatedPlaylists.Uploads // Print the playlist ID for the list of uploaded videos. fmt.Printf("Videos in list %s\r\n", playlistId) nextPageToken := "" for { // Retrieve next set of items in the playlist. playlistResponse := playlistItemsList(service, "snippet", playlistId, nextPageToken) for _, playlistItem := range playlistResponse.Items { title := playlistItem.Snippet.Title videoId := playlistItem.Snippet.ResourceId.VideoId fmt.Printf("%v, (%v)\r\n", title, videoId) } // Set the token to retrieve the next page of results // or exit the loop if all results have been retrieved. nextPageToken = playlistResponse.NextPageToken if nextPageToken == "" { break } fmt.Println() } } }
.NET
Im folgenden Codebeispiel wird die MethodeplaylistItems.list
der API aufgerufen, um eine Liste der Videos abzurufen, die auf den mit der Anfrage verknüpften Kanal hochgeladen wurden. Der Code ruft auch die Methode channels.list
auf, wobei der Parameter mine
auf true
gesetzt ist, um die Playlist-ID abzurufen, mit der die hochgeladenen Videos des Kanals identifiziert werden.
In diesem Beispiel wird die .NET-Clientbibliothek verwendet.
using System; using System.IO; using System.Reflection; using System.Threading; using System.Threading.Tasks; using Google.Apis.Auth.OAuth2; using Google.Apis.Services; using Google.Apis.Upload; using Google.Apis.Util.Store; using Google.Apis.YouTube.v3; using Google.Apis.YouTube.v3.Data; namespace Google.Apis.YouTube.Samples { /// <summary> /// YouTube Data API v3 sample: retrieve my uploads. /// Relies on the Google APIs Client Library for .NET, v1.7.0 or higher. /// See https://developers.google.com/api-client-library/dotnet/get_started /// </summary> internal class MyUploads { [STAThread] static void Main(string[] args) { Console.WriteLine("YouTube Data API: My Uploads"); Console.WriteLine("============================"); try { new MyUploads().Run().Wait(); } catch (AggregateException ex) { foreach (var e in ex.InnerExceptions) { Console.WriteLine("Error: " + e.Message); } } Console.WriteLine("Press any key to continue..."); Console.ReadKey(); } private async Task Run() { UserCredential credential; using (var stream = new FileStream("client_secrets.json", FileMode.Open, FileAccess.Read)) { credential = await GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load(stream).Secrets, // This OAuth 2.0 access scope allows for read-only access to the authenticated // user's account, but not other types of account access. new[] { YouTubeService.Scope.YoutubeReadonly }, "user", CancellationToken.None, new FileDataStore(this.GetType().ToString()) ); } var youtubeService = new YouTubeService(new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = this.GetType().ToString() }); var channelsListRequest = youtubeService.Channels.List("contentDetails"); channelsListRequest.Mine = true; // Retrieve the contentDetails part of the channel resource for the authenticated user's channel. var channelsListResponse = await channelsListRequest.ExecuteAsync(); foreach (var channel in channelsListResponse.Items) { // From the API response, extract the playlist ID that identifies the list // of videos uploaded to the authenticated user's channel. var uploadsListId = channel.ContentDetails.RelatedPlaylists.Uploads; Console.WriteLine("Videos in list {0}", uploadsListId); var nextPageToken = ""; while (nextPageToken != null) { var playlistItemsListRequest = youtubeService.PlaylistItems.List("snippet"); playlistItemsListRequest.PlaylistId = uploadsListId; playlistItemsListRequest.MaxResults = 50; playlistItemsListRequest.PageToken = nextPageToken; // Retrieve the list of videos uploaded to the authenticated user's channel. var playlistItemsListResponse = await playlistItemsListRequest.ExecuteAsync(); foreach (var playlistItem in playlistItemsListResponse.Items) { // Print information about each video. Console.WriteLine("{0} ({1})", playlistItem.Snippet.Title, playlistItem.Snippet.ResourceId.VideoId); } nextPageToken = playlistItemsListResponse.NextPageToken; } } } } }
Ruby
In diesem Beispiel wird die MethodeplaylistItems.list
der API aufgerufen, um eine Liste der Videos abzurufen, die auf den mit der Anfrage verknüpften Kanal hochgeladen wurden. Der Code ruft auch die Methode channels.list
auf, wobei der Parameter mine
auf true
gesetzt ist, um die Playlist-ID abzurufen, mit der die hochgeladenen Videos des Kanals identifiziert werden.
In diesem Beispiel wird die Ruby-Clientbibliothek verwendet.
#!/usr/bin/ruby require 'rubygems' gem 'google-api-client', '>0.7' require 'google/api_client' require 'google/api_client/client_secrets' require 'google/api_client/auth/file_storage' require 'google/api_client/auth/installed_app' # This OAuth 2.0 access scope allows for read-only access to the authenticated # user's account, but not other types of account access. YOUTUBE_READONLY_SCOPE = 'https://www.googleapis.com/auth/youtube.readonly' YOUTUBE_API_SERVICE_NAME = 'youtube' YOUTUBE_API_VERSION = 'v3' def get_authenticated_service client = Google::APIClient.new( :application_name => $PROGRAM_NAME, :application_version => '1.0.0' ) youtube = client.discovered_api(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION) file_storage = Google::APIClient::FileStorage.new("#{$PROGRAM_NAME}-oauth2.json") if file_storage.authorization.nil? client_secrets = Google::APIClient::ClientSecrets.load flow = Google::APIClient::InstalledAppFlow.new( :client_id => client_secrets.client_id, :client_secret => client_secrets.client_secret, :scope => [YOUTUBE_READONLY_SCOPE] ) client.authorization = flow.authorize(file_storage) else client.authorization = file_storage.authorization end return client, youtube end def main client, youtube = get_authenticated_service begin # Retrieve the "contentDetails" part of the channel resource for the # authenticated user's channel. channels_response = client.execute!( :api_method => youtube.channels.list, :parameters => { :mine => true, :part => 'contentDetails' } ) channels_response.data.items.each do |channel| # From the API response, extract the playlist ID that identifies the list # of videos uploaded to the authenticated user's channel. uploads_list_id = channel['contentDetails']['relatedPlaylists']['uploads'] # Retrieve the list of videos uploaded to the authenticated user's channel. next_page_token = '' until next_page_token.nil? playlistitems_response = client.execute!( :api_method => youtube.playlist_items.list, :parameters => { :playlistId => uploads_list_id, :part => 'snippet', :maxResults => 50, :pageToken => next_page_token } ) puts "Videos in list #{uploads_list_id}" # Print information about each video. playlistitems_response.data.items.each do |playlist_item| title = playlist_item['snippet']['title'] video_id = playlist_item['snippet']['resourceId']['videoId'] puts "#{title} (#{video_id})" end next_page_token = playlistitems_response.next_page_token end puts end rescue Google::APIClient::TransmissionError => e puts e.result.body end end main
Fehler
In der folgenden Tabelle sind Fehlermeldungen aufgeführt, die von der API möglicherweise als Antwort auf einen Aufruf dieser Methode zurückgegeben werden. Weitere Informationen finden Sie in der Dokumentation zu Fehlermeldungen.
Fehlertyp | Fehlerdetails | Beschreibung |
---|---|---|
forbidden (403) |
playlistItemsNotAccessible |
Die Anfrage ist nicht berechtigt, die angegebene Playlist abzurufen. |
forbidden (403) |
watchHistoryNotAccessible |
Daten zum Wiedergabeverlauf können nicht über die API abgerufen werden. |
forbidden (403) |
watchLaterNotAccessible |
Elemente in „Später ansehen“-Playlists können nicht über die API abgerufen werden. |
notFound (404) |
playlistNotFound |
Die Playlist, die mit dem Parameter playlistId der Anfrage identifiziert wurde, kann nicht gefunden werden. |
notFound (404) |
videoNotFound |
Das mit dem Parameter videoId der Anfrage identifizierte Video wurde nicht gefunden. |
required (400) |
playlistIdRequired |
In der Aboanfrage ist kein Wert für die erforderliche playlistId -Property angegeben. |
invalidValue (400) |
playlistOperationUnsupported |
Die API unterstützt nicht die Möglichkeit, Videos in der angegebenen Playlist aufzulisten. In der Playlist „Später ansehen“ kannst du beispielsweise kein Video auflisten. |
Testen!
Verwenden Sie APIs Explorer, um diese API aufzurufen und die API-Anfrage und -Antwort anzusehen.