Halaman ini diterjemahkan oleh Cloud Translation API.

PlaylistItems: list

Menampilkan kumpulan item playlist yang cocok dengan parameter permintaan API. Anda dapat mengambil semua item playlist dalam playlist yang ditentukan atau mengambil satu atau beberapa item playlist berdasarkan ID uniknya.

Dampak kuota: Panggilan ke metode ini memiliki biaya kuota 1 unit.

Kasus penggunaan umum

Permintaan

Permintaan HTTP

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

Parameter

Tabel berikut mencantumkan parameter yang didukung kueri ini. Semua parameter yang tercantum adalah parameter kueri.

Parameter
Parameter yang diperlukan
`part`	`string` Parameter `part` menentukan daftar yang dipisahkan koma dari satu atau beberapa properti resource `playlistItem` yang akan disertakan dalam respons API. Jika parameter mengidentifikasi properti yang berisi properti turunan, properti turunan akan disertakan dalam respons. Misalnya, dalam resource `playlistItem`, properti `snippet` berisi banyak kolom, termasuk properti `title`, `description`, `position`, dan `resourceId`. Dengan demikian, jika Anda menyetel `part=snippet`, respons API akan berisi semua properti tersebut. Daftar berikut berisi nama `part` yang dapat Anda sertakan dalam nilai parameter: `contentDetails` `id` `snippet` `status`
Filter (sebutkan salah satu parameter berikut)
`id`	`string` Parameter `id` menentukan daftar yang dipisahkan koma dari satu atau beberapa ID item playlist unik.
`playlistId`	`string` Parameter `playlistId` menentukan ID unik playlist yang ingin Anda ambil item playlist-nya. Perlu diperhatikan bahwa meskipun ini adalah parameter opsional, setiap permintaan untuk mengambil item playlist harus menentukan nilai untuk parameter `id` atau parameter `playlistId`.
Parameter opsional
`maxResults`	`unsigned integer` Parameter `maxResults` menentukan jumlah maksimum item yang harus ditampilkan dalam kumpulan hasil. Nilai yang dapat diterima adalah `0` hingga `50`, inklusif. Nilai defaultnya adalah `5`.
`onBehalfOfContentOwner`	`string` Parameter ini hanya dapat digunakan dalam permintaan yang diizinkan dengan benar. Catatan: Parameter ini ditujukan secara eksklusif untuk partner konten YouTube. Parameter `onBehalfOfContentOwner` menunjukkan bahwa kredensial otorisasi permintaan mengidentifikasi pengguna CMS YouTube yang bertindak atas nama pemilik konten yang ditentukan dalam nilai parameter. Parameter ini ditujukan untuk partner konten YouTube yang memiliki dan mengelola berbagai channel YouTube. Dengan kebijakan ini, pemilik konten dapat mengautentikasi sekali serta mendapatkan akses ke semua data video dan channel mereka, tanpa harus memberikan kredensial autentikasi untuk setiap channel. Akun CMS yang diautentikasi pengguna harus ditautkan dengan pemilik konten YouTube yang ditentukan.
`pageToken`	`string` Parameter `pageToken` mengidentifikasi halaman tertentu dalam kumpulan hasil yang harus ditampilkan. Dalam respons API, properti `nextPageToken` dan `prevPageToken` mengidentifikasi halaman lain yang dapat diambil.
`videoId`	`string` Parameter `videoId` menentukan bahwa permintaan hanya boleh menampilkan item playlist yang berisi video yang ditentukan.

Isi permintaan

Jangan berikan isi permintaan saat memanggil metode ini.

Tanggapan

Jika berhasil, metode ini akan menampilkan isi respons dengan struktur berikut:

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

Properti

Tabel berikut menentukan properti yang muncul di resource ini:

Properti
`kind`	`string` Mengidentifikasi jenis resource API. Nilainya adalah `youtube#playlistItemListResponse`.
`etag`	`etag` Etag resource ini.
`nextPageToken`	`string` Token yang dapat digunakan sebagai nilai parameter `pageToken` untuk mengambil halaman berikutnya dalam kumpulan hasil.
`prevPageToken`	`string` Token yang dapat digunakan sebagai nilai parameter `pageToken` untuk mengambil halaman sebelumnya dalam kumpulan hasil.
`pageInfo`	`object` Objek `pageInfo` mengenkapsulasi informasi paging untuk kumpulan hasil.
`pageInfo.totalResults`	`integer` Total jumlah hasil dalam kumpulan hasil.
`pageInfo.resultsPerPage`	`integer` Jumlah hasil yang disertakan dalam respons API.
`items[]`	`list` Daftar item playlist yang cocok dengan kriteria permintaan.

Contoh

Catatan: Contoh kode berikut mungkin tidak mewakili semua bahasa pemrograman yang didukung. Lihat dokumentasi library klien untuk mengetahui daftar bahasa yang didukung.

Go

Contoh kode ini memanggil metode playlistItems.list API untuk mengambil daftar video yang diupload ke saluran yang terkait dengan permintaan. Kode tersebut juga memanggil metode channels.list dengan parameter mine yang disetel ke true untuk mengambil ID playlist yang mengidentifikasi video yang diupload channel.

Contoh ini menggunakan library klien 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

Contoh kode berikut memanggil metode playlistItems.list API untuk mengambil daftar video yang diupload ke saluran yang terkait dengan permintaan. Kode tersebut juga memanggil metode channels.list dengan parameter mine yang disetel ke true untuk mengambil ID playlist yang mengidentifikasi video yang diupload channel.

Contoh ini menggunakan library klien.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

Ruby

Contoh ini memanggil metode playlistItems.list API untuk mengambil daftar video yang diupload ke saluran yang terkait dengan permintaan. Kode tersebut juga memanggil metode channels.list dengan parameter mine yang disetel ke true untuk mengambil ID playlist yang mengidentifikasi video yang diupload di channel.

Contoh ini menggunakan library klien 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

Error

Tabel berikut mengidentifikasi pesan error yang dapat ditampilkan API sebagai respons terhadap panggilan ke metode ini. Lihat dokumentasi pesan error untuk mengetahui detail selengkapnya.

Jenis error	Detail error	Deskripsi
`forbidden (403)`	`playlistItemsNotAccessible`	Permintaan tidak diotorisasi dengan benar untuk mengambil playlist yang ditentukan.
`forbidden (403)`	`watchHistoryNotAccessible`	Data histori tontonan tidak dapat diambil melalui API.
`forbidden (403)`	`watchLaterNotAccessible`	Item dalam playlist "tonton nanti" tidak dapat diambil melalui API.
`notFound (404)`	`playlistNotFound`	Playlist yang diidentifikasi dengan parameter `playlistId` permintaan tidak dapat ditemukan.
`notFound (404)`	`videoNotFound`	Video yang diidentifikasi dengan parameter `videoId` permintaan tidak dapat ditemukan.
`required (400)`	`playlistIdRequired`	Permintaan berlangganan tidak menentukan nilai untuk properti `playlistId` yang diperlukan.
`invalidValue (400)`	`playlistOperationUnsupported`	API tidak mendukung kemampuan untuk mencantumkan video dalam playlist yang ditentukan. Misalnya, Anda tidak dapat mencantumkan video dalam playlist tonton nanti.

Cobalah!

Gunakan APIs Explorer untuk memanggil API ini dan melihat permintaan dan respons API.