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.

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: `contentDetails` `id` `snippet` `status`
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 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, 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()
		}
	}
}
my_uploads.go

.NET

Im folgenden Codebeispiel 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, 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;
        }
      }
    }
  }
}
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, 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
my_uploads.rb

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.