Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

PlaylistItems: list

Gibt eine Sammlung von Playlist-Elementen zurück, die den Parametern der API-Anfrage entsprechen. Sie können alle Playlist-Elemente in einer bestimmten Playlist oder ein oder mehrere Playlist-Elemente anhand ihrer eindeutigen IDs abrufen.

Kontingentbelastung:Ein Aufruf dieser Methode hat eine Kontingentbelastung von 1 Einheit.

Gängige Anwendungsfälle

Anfrage

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 einem oder mehreren Attributen der Ressource `playlistItem` an, die in der API-Antwort enthalten sein sollen. Wenn der Parameter ein Attribut identifiziert, das untergeordnete Attribute enthält, werden diese untergeordneten Attribute in die Antwort aufgenommen. In einer `playlistItem`-Ressource enthält das Attribut `snippet` beispielsweise zahlreiche Felder, darunter die Attribute `title`, `description`, `position` und `resourceId`. Wenn Sie also `part=snippet` festlegen, enthält die API-Antwort 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 Sie Playlist-Elemente abrufen möchten. Obwohl dies ein optionaler Parameter ist, muss in jeder Anfrage zum Abrufen von Playlist-Elementen ein Wert für den Parameter `id` oder den Parameter `playlistId` angegeben werden.
Optionale Parameter
`maxResults`	`unsigned integer` Der Parameter `maxResults` gibt die maximale Anzahl der Elemente an, die im Ergebnissatz 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-Content-Partner vorgesehen. Der `onBehalfOfContentOwner` Parameter gibt an, dass die Autorisierungsdaten der Anfrage einen YouTube-CMS-Nutzer identifizieren, der im Namen des im Parameterwert angegebenen Content-Inhabers handelt. Dieser Parameter ist für YouTube-Content-Partner vorgesehen, die viele verschiedene YouTube-Kanäle besitzen und verwalten. So können sich Rechteinhaber 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 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 Playlist-Elemente 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 sind die Attribute definiert, die in dieser Ressource enthalten sind:

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 Objekt `pageInfo` enthält Informationen zur Paginierung 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 von Playlist-Elementen, die den Anfragekriterien entsprechen.

Beispiele

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

Ok

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. Außerdem wird die channels.list Methode aufgerufen, wobei der mine Parameter 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

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. Außerdem wird 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. Außerdem wird 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 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 die Fehlermeldungen aufgeführt, die die API als Antwort auf einen Aufruf dieser Methode zurückgeben kann. Weitere Informationen finden Sie in der Dokumentation zu Fehlermeldungen.

Fehlertyp	Fehlerdetails	Beschreibung
`forbidden (403)`	`playlistItemsNotAccessible`	Die Anfrage ist nicht ordnungsgemäß autorisiert, um die angegebene Playlist abzurufen.
`forbidden (403)`	`watchHistoryNotAccessible`	Daten zum Wiedergabeverlauf können nicht über die API abgerufen werden.
`forbidden (403)`	`watchLaterNotAccessible`	Elemente in Playlists vom Typ „Später ansehen“ 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 Video, das mit dem Parameter `videoId` der Anfrage identifiziert wurde, kann nicht gefunden werden.
`required (400)`	`playlistIdRequired`	In der Anfrage zum Abonnieren wurde kein Wert für das erforderliche Attribut `playlistId` angegeben.
`invalidValue (400)`	`playlistOperationUnsupported`	Die API unterstützt nicht die Möglichkeit, Videos in der angegebenen Playlist aufzulisten. Sie können beispielsweise kein Video in Ihrer Playlist „Später ansehen“ auflisten.

Testen!

Mit dem APIs Explorer können Sie diese API aufrufen und sich die API-Anfrage und -Antwort ansehen.

PlaylistItems: list Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.