Se usó la API de Cloud Translation para traducir esta página.

PlaylistItems: list

Muestra una colección de elementos de una lista de reproducción que coinciden con los parámetros de solicitud de la API. Puedes recuperar todos los elementos de una lista de reproducción en una lista de reproducción específica o recuperar uno o más elementos de una lista de reproducción mediante sus ID únicos.

Impacto de la cuota: Una llamada a este método tiene un costo de cuota de 1 unidad.

Casos de uso habituales

Solicitud

Solicitud HTTP

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

Parámetros

En la siguiente tabla, se enumeran los parámetros que admite esta consulta. Todos los parámetros mencionados son parámetros de consulta.

Parámetros
Parámetros obligatorios
`part`	`string` El parámetro `part` especifica una lista separada por comas de una o más propiedades de recursos de `playlistItem` que la respuesta de la API incluirá. Si el parámetro identifica una propiedad que contiene propiedades secundarias, estas se incluirán en la respuesta. Por ejemplo, en un recurso `playlistItem`, la propiedad `snippet` contiene varios campos, incluidos `title`, `description`, `position` y `resourceId`. Por lo tanto, si configuras `part=snippet`, la respuesta de la API contendrá todas esas propiedades. La siguiente lista contiene los nombres de `part` que puedes incluir en el valor del parámetro: `contentDetails` `id` `snippet` `status`
Filtros (especifica exactamente uno de los siguientes parámetros)
`id`	`string` El parámetro `id` especifica una lista separada por comas de uno o más IDs únicos de elementos de playlists.
`playlistId`	`string` El parámetro `playlistId` especifica el ID único de la playlist cuya playlist deseas recuperar. Ten en cuenta que, aunque este es un parámetro opcional, cada solicitud para recuperar elementos de listas de reproducción debe especificar un valor para el parámetro `id` o `playlistId`.
Parámetros opcionales
`maxResults`	`unsigned integer` El parámetro `maxResults` especifica la cantidad máxima de elementos que se deben mostrar en el conjunto de resultados. Los valores aceptables son `0` a `50`, ambos inclusive. El valor predeterminado es `5`.
`onBehalfOfContentOwner`	`string` Este parámetro solo se puede usar en una solicitud autorizada debidamente. Nota: Este parámetro está dirigido exclusivamente a socios de contenido de YouTube. El parámetro `onBehalfOfContentOwner` indica que las credenciales de autorización de la solicitud identifican a un usuario de CMS de YouTube que actúa en nombre del propietario del contenido especificado en el valor del parámetro. Este parámetro está dirigido a socios de contenido de YouTube que poseen y administran varios canales de YouTube diferentes. Permite a los propietarios del contenido autenticarse una vez y tener acceso a todos los datos de sus videos y canales, sin tener que proporcionar credenciales de autenticación para cada canal. La cuenta de CMS con la que se autentica el usuario debe estar relacionada con el propietario del contenido de YouTube especificado.
`pageToken`	`string` El parámetro `pageToken` identifica una página específica en el conjunto de resultados que se debe mostrar. En una respuesta de la API, las propiedades `nextPageToken` y `prevPageToken` identifican otras páginas que se podrían recuperar.
`videoId`	`string` El parámetro `videoId` especifica que la solicitud debe mostrar solo los elementos de la playlist que contengan el video especificado.

Cuerpo de la solicitud

No proporciones un cuerpo de solicitud cuando invoques este método.

Respuesta

Si se aplica correctamente, este método muestra un cuerpo de respuesta con la siguiente estructura:

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

Propiedades

La siguiente tabla define las propiedades que aparecen en este recurso:

Propiedades
`kind`	`string` Identifica el tipo de recurso de la API. El valor será `youtube#playlistItemListResponse`.
`etag`	`etag` La Etag de este recurso.
`nextPageToken`	`string` Es el token que se puede usar como valor del parámetro `pageToken` para recuperar la página siguiente en el conjunto de resultados.
`prevPageToken`	`string` Es el token que se puede usar como valor del parámetro `pageToken` para recuperar la página anterior en el conjunto de resultados.
`pageInfo`	`object` El objeto `pageInfo` contiene información de paginación para el conjunto de resultados.
`pageInfo.totalResults`	`integer` Es la cantidad total de resultados en el conjunto de resultados.
`pageInfo.resultsPerPage`	`integer` Cantidad de resultados incluidos en la respuesta de la API.
`items[]`	`list` Una lista de elementos de listas de reproducción que coinciden con los criterios de la solicitud.

Ejemplos

Nota: Es posible que las siguientes muestras de código no representen todos los lenguajes de programación admitidos. Consulta la documentación de bibliotecas cliente para obtener una lista de los lenguajes admitidos.

Go

Esta muestra de código invoca el método playlistItems.list de la API para recuperar una lista de videos subidos al canal asociado con la solicitud. El código también llama al método channels.list con el parámetro mine establecido en true para recuperar el ID de la playlist que identifica los videos subidos del canal.

En este ejemplo, se utiliza la biblioteca cliente de 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()
		}
	}
}
my_uploads.go

.NET

La siguiente muestra de código invoca el método playlistItems.list de la API para recuperar una lista de videos subidos al canal asociado con la solicitud. El código también llama al método channels.list con el parámetro mine establecido en true para recuperar el ID de la playlist que identifica los videos subidos al canal.

En este ejemplo se utiliza la biblioteca 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;
        }
      }
    }
  }
}
MyUploads.cs

Rita

En este ejemplo, se llama al método playlistItems.list de la API para recuperar una lista de los videos que se subieron al canal asociado con la solicitud. El código también llama al método channels.list con el parámetro mine configurado en true para recuperar el ID de la playlist que identifica los videos subidos del canal.

En este ejemplo se utiliza la biblioteca 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
my_uploads.rb

Errores

En la siguiente tabla se identifican los mensajes de error que la API podría mostrar en respuesta a una llamada a este método. Consulta la documentación sobre mensajes de error para obtener más información.

Tipo de error	Detalle del error	Descripción
`forbidden (403)`	`playlistItemsNotAccessible`	La solicitud no está debidamente autorizada para recuperar la lista de reproducción especificada.
`forbidden (403)`	`watchHistoryNotAccessible`	Los datos del historial de reproducciones no se pueden recuperar a través de la API.
`forbidden (403)`	`watchLaterNotAccessible`	Los elementos de las playlists "Ver más tarde" no se pueden recuperar mediante la API.
`notFound (404)`	`playlistNotFound`	No se puede encontrar la playlist identificada con el parámetro `playlistId` de la solicitud.
`notFound (404)`	`videoNotFound`	No se puede encontrar el video identificado con el parámetro `videoId` de la solicitud.
`required (400)`	`playlistIdRequired`	La solicitud de suscripción no especifica un valor para la propiedad `playlistId` requerida.
`invalidValue (400)`	`playlistOperationUnsupported`	La API no admite la capacidad de mostrar videos en la playlist especificada. Por ejemplo, no puedes incluir un video en la playlist Ver más tarde.

Pruébalo

Usa APIs Explorer para llamar a esta API y ver la solicitud y la respuesta a la API.