PlaylistItems: list

Renvoie un ensemble d'éléments de playlist qui correspondent aux paramètres de requête de l'API. Vous pouvez récupérer tous les éléments d'une playlist donnée ou en extraire un ou plusieurs par ID.

Impact du quota : un appel à cette méthode a un coût de quota de 1 unité.

Cas d'utilisation courants

Demande

Requête HTTP :

GET https://www.googleapis.com/youtube/v3/playlistItems

Paramètres

Le tableau suivant répertorie les paramètres compatibles avec cette requête. Tous les paramètres listés sont des paramètres de requête.

Paramètres
Réglages obligatoires
part string
Le paramètre part spécifie une liste d'une ou de plusieurs propriétés de ressources playlistItem qui seront incluses dans la réponse de l'API.

Si le paramètre identifie une propriété contenant des propriétés enfants, celles-ci seront incluses dans la réponse. Par exemple, dans une ressource playlistItem, la propriété snippet contient de nombreux champs, y compris les propriétés title, description, position et resourceId. Par conséquent, si vous définissez part=snippet, la réponse de l'API contiendra toutes ces propriétés.

La liste suivante contient les noms part que vous pouvez inclure dans la valeur du paramètre:
  • contentDetails
  • id
  • snippet
  • status
Filtres (spécifier exactement l'un des paramètres suivants)
id string
Le paramètre id spécifie une liste d'ID de playlist uniques séparés par une virgule.
playlistId string
Le paramètre playlistId spécifie l'ID unique de la playlist pour laquelle vous souhaitez récupérer des éléments. Notez que même s'il s'agit d'un paramètre facultatif, chaque requête de récupération d'éléments de playlist doit spécifier une valeur pour le paramètre id ou playlistId.
Paramètres facultatifs
maxResults unsigned integer
Le paramètre maxResults spécifie le nombre maximal d'éléments à renvoyer dans l'ensemble de résultats. Les valeurs autorisées vont de 0 à 50, inclus. La valeur par défaut est 5.
onBehalfOfContentOwner string
Ce paramètre ne peut être utilisé que dans une requête correctement autorisée. Remarque:Ce paramètre est réservé aux partenaires de contenu YouTube.

Le paramètre onBehalfOfContentOwner indique que les identifiants d'autorisation de la demande identifient un utilisateur du CMS YouTube qui agit au nom du propriétaire de contenu spécifié dans la valeur du paramètre. Ce paramètre est destiné aux partenaires de contenu YouTube qui possèdent et gèrent de nombreuses chaînes différentes. Elle permet aux propriétaires de contenu de s'authentifier une seule fois et d'accéder à toutes les données de leurs vidéos et de leur chaîne, sans avoir à fournir d'identifiants pour chaque chaîne. Le compte CMS avec lequel l'utilisateur s'authentifie doit être associé au propriétaire de contenu YouTube spécifié.
pageToken string
Le paramètre pageToken identifie une page spécifique de l'ensemble de résultats à renvoyer. Dans une réponse d'API, les propriétés nextPageToken et prevPageToken identifient d'autres pages qui pourraient être récupérées.
videoId string
Le paramètre videoId indique que la requête ne doit renvoyer que les éléments de la playlist qui contiennent la vidéo spécifiée.

Corps de la requête

Ne fournissez pas de corps de requête lorsque vous appelez cette méthode.

Réponse

Si la requête aboutit, cette méthode renvoie un corps de réponse présentant la structure suivante :

{
  "kind": "youtube#playlistItemListResponse",
  "etag": etag,
  "nextPageToken": string,
  "prevPageToken": string,
  "pageInfo": {
    "totalResults": integer,
    "resultsPerPage": integer
  },
  "items": [
    playlistItem Resource
  ]
}

Propriétés

Le tableau suivant définit les propriétés qui apparaissent dans cette ressource:

Propriétés
kind string
Identifie le type de ressource de l'API. La valeur sera youtube#playlistItemListResponse.
etag etag
ETag de cette ressource.
nextPageToken string
Jeton pouvant être utilisé comme valeur du paramètre pageToken pour extraire la page suivante de l'ensemble de résultats.
prevPageToken string
Jeton pouvant être utilisé comme valeur du paramètre pageToken pour récupérer la page précédente dans l'ensemble de résultats.
pageInfo object
L'objet pageInfo encapsule les informations de pagination pour l'ensemble de résultats.
pageInfo.totalResults integer
Nombre total de résultats dans l'ensemble de résultats.
pageInfo.resultsPerPage integer
Nombre de résultats inclus dans la réponse de l'API.
items[] list
Liste d'éléments de playlist correspondant aux critères de la demande.

Exemples

Remarque : Les exemples de code suivants peuvent ne pas représenter tous les langages de programmation compatibles. Consultez la documentation sur les bibliothèques clientes pour obtenir la liste des langages compatibles.

Go

Cet exemple de code appelle la méthode playlistItems.list de l'API pour récupérer la liste des vidéos mises en ligne sur la chaîne associée à la requête. Le code appelle également la méthode channels.list avec le paramètre mine défini sur true pour récupérer l'ID de la playlist qui identifie les vidéos mises en ligne sur la chaîne.

Cet exemple utilise la bibliothèque cliente Go.

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

L'exemple de code suivant appelle la méthode playlistItems.list de l'API pour récupérer la liste des vidéos mises en ligne sur la chaîne associée à la requête. Le code appelle également la méthode channels.list avec le paramètre mine défini sur true pour récupérer l'ID de la playlist qui identifie les vidéos mises en ligne sur la chaîne.

Cet exemple utilise la bibliothèque cliente.NET.

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

Cet exemple appelle la méthode playlistItems.list de l'API pour récupérer la liste des vidéos mises en ligne sur la chaîne associée à la requête. Le code appelle également la méthode channels.list avec le paramètre mine défini sur true pour récupérer l'ID de la playlist qui identifie les vidéos mises en ligne sur la chaîne.

Cet exemple utilise la bibliothèque cliente Ruby.

#!/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

Erreurs

Le tableau suivant identifie les messages d'erreur que l'API pourrait renvoyer en réponse à un appel à cette méthode. Veuillez consulter la documentation sur les messages d'erreur pour en savoir plus.

Type d'erreur Détails de l'erreur Description
forbidden (403) playlistItemsNotAccessible La demande n'est pas correctement autorisée à récupérer la playlist spécifiée.
forbidden (403) watchHistoryNotAccessible Les données de l'historique des vidéos regardées ne peuvent pas être récupérées via l'API.
forbidden (403) watchLaterNotAccessible Les éléments des playlists "À regarder plus tard" ne peuvent pas être récupérés via l'API.
notFound (404) playlistNotFound La playlist identifiée avec le paramètre playlistId de la requête est introuvable.
notFound (404) videoNotFound Impossible de trouver la vidéo identifiée par le paramètre videoId de la demande.
required (400) playlistIdRequired La requête d'abonnement ne spécifie aucune valeur pour la propriété playlistId requise.
invalidValue (400) playlistOperationUnsupported L'API ne permet pas de répertorier des vidéos dans la playlist spécifiée. Par exemple, vous ne pouvez pas ajouter une vidéo à la playlist "À regarder plus tard".

Essayer

Utilisez APIs Explorer pour appeler cette API et afficher la requête API et la réponse.