Diese Seite wurde von der Cloud Translation API übersetzt.

PlaylistItems: list

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.

Kontingentauswirkung: Ein Aufruf dieser Methode hat Kontingentkosten von 1 Einheit.

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` Mit dem Parameter `part` wird eine durch Kommas getrennte Liste mit einem oder mehreren `playlistItem`-Ressourcenattributen angegeben, die in der API-Antwort enthalten sein werden. Bezeichnet der Parameter eine Property, die untergeordnete Properties enthält, werden die untergeordneten Attribute in die Antwort aufgenommen. Beispielsweise enthält das Attribut `snippet` in einer `playlistItem`-Ressource zahlreiche Felder, darunter die Attribute `title`, `description`, `position` und `resourceId`. Wenn du also `part=snippet` festlegst, enthält die API-Antwort alle diese Eigenschaften. Die folgende Liste enthält die `part`-Namen, die du in den Parameterwert aufnehmen kannst: `contentDetails` `id` `snippet` `status`
Filter (geben Sie genau einen der folgenden Parameter an)
`id`	`string` Der Parameter `id` enthält eine durch Kommas getrennte Liste einer oder mehrerer eindeutiger Playlist-Element-IDs.
`playlistId`	`string` Der Parameter `playlistId` gibt die eindeutige ID der Playlist an, für die du Playlist-Elemente abrufen möchtest. Auch wenn dies ein optionaler Parameter ist, muss in jeder Anfrage zum Abrufen von Playlist-Elementen ein Wert für den `id`- oder `playlistId`-Parameter 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` (einschließlich). 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-Contentpartner vorgesehen. Der Parameter `onBehalfOfContentOwner` gibt an, dass durch die Autorisierungsanmeldedaten der Anfrage ein YouTube CMS-Nutzer identifiziert wird, 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 nur einmal authentifizieren und auf alle ihre Video- und Kanaldaten zugreifen, ohne für jeden einzelnen Kanal Authentifizierungsdaten 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 `pageToken`-Parameter gibt eine bestimmte Seite in der Ergebnismenge an, die zurückgegeben werden soll. In einer API-Antwort identifizieren die Attribute `nextPageToken` und `prevPageToken` andere Seiten, die abgerufen werden könnten.
`videoId`	`string` Der Parameter `videoId` gibt an, dass in der Anfrage nur die Playlist-Elemente zurückgegeben werden sollen, 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 in der Ergebnismenge abzurufen.
`prevPageToken`	`string` Das Token, das als Wert des Parameters `pageToken` verwendet werden kann, um die vorherige Seite in der Ergebnismenge abzurufen.
`pageInfo`	`object` Das Objekt `pageInfo` enthält Seiteninformationen für den Ergebnissatz.
`pageInfo.totalResults`	`integer` Die Gesamtzahl der Ergebnisse im Ergebnissatz.
`pageInfo.resultsPerPage`	`integer` Die Anzahl der Ergebnisse, die in der API-Antwort enthalten sind.
`items[]`	`list` Eine Liste der Playlist-Elemente, die den Anfragekriterien entsprechen.

Beispiele

Hinweis:Die folgenden Codebeispiele repräsentieren möglicherweise nicht alle unterstützten Programmiersprachen. Eine Liste der unterstützten Sprachen finden Sie in der Dokumentation zu Clientbibliotheken.

Ok

In diesem Codebeispiel wird die Methode playlistItems.list der API aufgerufen, um eine Liste von 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, die die hochgeladenen Videos des Kanals identifiziert.

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()
		}
	}
}
my_uploads.go

.NET

Im folgenden Codebeispiel wird die Methode playlistItems.list der API aufgerufen, um eine Liste von Videos abzurufen, die in den mit der Anfrage verknüpften Kanal hochgeladen wurden. Mit dem Code wird auch die Methode channels.list aufgerufen, wobei der Parameter mine auf true gesetzt ist, um die Playlist-ID abzurufen, die die hochgeladenen Videos des Kanals identifiziert.

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;
        }
      }
    }
  }
}
MyUploads.cs

Ruby

In diesem Beispiel wird die Methode playlistItems.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, die die hochgeladenen Videos des Kanals identifiziert.

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
my_uploads.rb

Fehler

In der folgenden Tabelle finden Sie Fehlermeldungen, die die API als Antwort auf einen Aufruf dieser Methode zurückgeben könnte. 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 mit dem Parameter `playlistId` der Anfrage identifizierte Playlist wurde nicht gefunden.
`notFound (404)`	`videoNotFound`	Das Video, das mit dem Parameter `videoId` der Anfrage identifiziert wurde, wurde nicht gefunden.
`required (400)`	`playlistIdRequired`	Die Abonnieren-Anfrage enthält keinen Wert für das erforderliche Attribut `playlistId`.
`invalidValue (400)`	`playlistOperationUnsupported`	Die API unterstützt nicht die Möglichkeit, Videos in der angegebenen Playlist aufzulisten. So ist es beispielsweise nicht möglich, ein Video der Playlist „Später ansehen“ hinzuzufügen.

Jetzt testen

Verwenden Sie APIs Explorer, um diese API aufzurufen und die API-Anfrage und -Antwort anzusehen.