PlaylistItems: list

แสดงผลคอลเล็กชันรายการเพลย์ลิสต์ที่ตรงกับพารามิเตอร์คำขอ API คุณสามารถดึงรายการเพลย์ลิสต์ทั้งหมดในเพลย์ลิสต์ที่ระบุ หรือดึงรายการเพลย์ลิสต์อย่างน้อยหนึ่งรายการตามรหัสที่ไม่ซ้ำกัน

ผลกระทบของโควต้า: การเรียกใช้เมธอดนี้มีต้นทุนโควต้าเท่ากับ 1 หน่วย

Use Case ทั่วไป

ส่งคำขอ

คำขอ HTTP

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

พารามิเตอร์

ตารางต่อไปนี้แสดงพารามิเตอร์ที่การค้นหานี้รองรับ พารามิเตอร์ทั้งหมดที่แสดงอยู่เป็นพารามิเตอร์การค้นหา

พารามิเตอร์
พารามิเตอร์ที่จำเป็น
part	string พารามิเตอร์ part ระบุรายการที่คั่นด้วยคอมมาของพร็อพเพอร์ตี้ทรัพยากร playlistItem อย่างน้อย 1 รายการซึ่งการตอบกลับจาก API จะรวมไว้ด้วย หากพารามิเตอร์ระบุพร็อพเพอร์ตี้ที่มีพร็อพเพอร์ตี้ย่อย พร็อพเพอร์ตี้ย่อยจะรวมอยู่ในการตอบกลับ เช่น ในทรัพยากร playlistItem พร็อพเพอร์ตี้ snippet จะมีช่องหลายช่อง เช่น พร็อพเพอร์ตี้ title, description, position และ resourceId ดังนั้น หากคุณตั้งค่า part=snippet การตอบกลับจาก API จะมีพร็อพเพอร์ตี้เหล่านั้นทั้งหมด รายการต่อไปนี้มีชื่อ part ที่คุณรวมไว้ในค่าพารามิเตอร์ได้ contentDetails id snippet status
ตัวกรอง (ระบุพารามิเตอร์รายการใดรายการหนึ่งต่อไปนี้เท่านั้น)
id	string พารามิเตอร์ id จะระบุรายการรหัสรายการเพลย์ลิสต์ที่ไม่ซ้ำกันอย่างน้อย 1 รายการซึ่งคั่นด้วยคอมมา
playlistId	string พารามิเตอร์ playlistId จะระบุรหัสที่ไม่ซ้ำกันของเพลย์ลิสต์ที่คุณต้องการเรียกดูรายการเพลย์ลิสต์ โปรดทราบว่าแม้จะเป็นพารามิเตอร์ที่ไม่บังคับ แต่ทุกคำขอในการเรียกรายการเพลย์ลิสต์จะต้องระบุค่าสำหรับพารามิเตอร์ id หรือพารามิเตอร์ playlistId
พารามิเตอร์ที่ไม่บังคับ
maxResults	unsigned integer พารามิเตอร์ maxResults จะระบุจำนวนรายการสูงสุดที่ควรแสดงผลในชุดผลลัพธ์ ค่าที่ยอมรับได้คือ 0 ถึง 50 ค่าเริ่มต้นคือ 5
onBehalfOfContentOwner	string พารามิเตอร์นี้ใช้ได้เฉพาะในคำขอที่ได้รับอนุญาตที่เหมาะสมเท่านั้น หมายเหตุ: พารามิเตอร์นี้มีไว้สำหรับพาร์ทเนอร์เนื้อหาของ YouTube เท่านั้น พารามิเตอร์ onBehalfOfContentOwner ระบุว่าข้อมูลเข้าสู่ระบบการให้สิทธิ์ของคำขอระบุผู้ใช้ YouTube CMS ที่ดำเนินการในนามของเจ้าของเนื้อหาที่ระบุไว้ในค่าพารามิเตอร์ พารามิเตอร์นี้มีไว้สำหรับพาร์ทเนอร์เนื้อหาของ YouTube ที่เป็นเจ้าของและจัดการช่อง YouTube หลายช่อง ซึ่งช่วยให้เจ้าของเนื้อหาตรวจสอบสิทธิ์เพียงครั้งเดียวและมีสิทธิ์เข้าถึงข้อมูลวิดีโอและช่องทั้งหมดของตนโดยไม่ต้องระบุข้อมูลเข้าสู่ระบบการตรวจสอบสิทธิ์สำหรับแต่ละช่อง บัญชี CMS ที่ผู้ใช้ตรวจสอบสิทธิ์จะต้องลิงก์กับเจ้าของเนื้อหา YouTube ที่ระบุ
pageToken	string พารามิเตอร์ pageToken จะระบุหน้าเว็บที่เฉพาะเจาะจงในชุดผลลัพธ์ที่ควรแสดง ในการตอบกลับของ API พร็อพเพอร์ตี้ nextPageToken และ prevPageToken จะระบุหน้าอื่นๆ ที่ดึงได้
videoId	string พารามิเตอร์ videoId ระบุว่าคำขอควรแสดงผลเฉพาะรายการเพลย์ลิสต์ที่มีวิดีโอที่ระบุเท่านั้น

เนื้อหาของคำขอ

ไม่ต้องระบุเนื้อหาคำขอเมื่อเรียกใช้วิธีการนี้

คำตอบ

หากทำสำเร็จ เมธอดนี้จะแสดงเนื้อหาการตอบสนองที่มีโครงสร้างต่อไปนี้

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

พร็อพเพอร์ตี้

ตารางต่อไปนี้จะกำหนดพร็อพเพอร์ตี้ที่ปรากฏในทรัพยากรนี้

พร็อพเพอร์ตี้
kind	string ระบุประเภทของทรัพยากร API ค่าจะเป็น youtube#playlistItemListResponse
etag	etag Etag ของแหล่งข้อมูลนี้
nextPageToken	string โทเค็นที่ใช้เป็นค่าของพารามิเตอร์ pageToken เพื่อดึงหน้าถัดไปในชุดผลลัพธ์
prevPageToken	string โทเค็นที่ใช้เป็นค่าของพารามิเตอร์ pageToken เพื่อดึงหน้าก่อนหน้าในชุดผลลัพธ์ได้
pageInfo	object ออบเจ็กต์ pageInfo สรุปข้อมูลการแบ่งหน้าสำหรับชุดผลลัพธ์
pageInfo.totalResults	integer จำนวนผลลัพธ์ทั้งหมดในชุดผลลัพธ์
pageInfo.resultsPerPage	integer จำนวนผลลัพธ์ที่รวมอยู่ในการตอบกลับของ API
items[]	list รายการเพลย์ลิสต์ที่ตรงกับเกณฑ์คำขอ

ตัวอย่าง

หมายเหตุ: ตัวอย่างโค้ดต่อไปนี้อาจไม่ได้แสดงถึงภาษาโปรแกรมที่รองรับทั้งหมด โปรดดูรายการภาษาที่รองรับในเอกสารประกอบของไลบรารีของไคลเอ็นต์

Go

ตัวอย่างโค้ดนี้เรียกใช้เมธอด playlistItems.list ของ API เพื่อเรียกข้อมูลรายการวิดีโอที่อัปโหลดไปยังช่องที่เชื่อมโยงกับคำขอ โค้ดยังเรียกใช้เมธอด channels.list ที่มีการตั้งค่าพารามิเตอร์ mine เป็น true เพื่อดึงรหัสเพลย์ลิสต์ที่ระบุวิดีโอที่อัปโหลดของช่องด้วย

ตัวอย่างนี้ใช้ไลบรารีของไคลเอ็นต์ 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

ตัวอย่างโค้ดต่อไปนี้เรียกใช้เมธอด playlistItems.list ของ API เพื่อเรียกข้อมูลรายการวิดีโอที่อัปโหลดไปยังช่องที่เชื่อมโยงกับคำขอ นอกจากนี้ โค้ดยังเรียกใช้เมธอด channels.list ที่มีการตั้งค่าพารามิเตอร์ mine เป็น true เพื่อดึงรหัสเพลย์ลิสต์ที่ระบุวิดีโอที่อัปโหลดของช่อง

ตัวอย่างนี้ใช้ไลบรารีของไคลเอ็นต์ .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

ตัวอย่างนี้เรียกใช้เมธอด playlistItems.list ของ API เพื่อเรียกข้อมูลรายการวิดีโอที่อัปโหลดไปยังช่องที่เชื่อมโยงกับคำขอ นอกจากนี้ โค้ดยังเรียกใช้เมธอด channels.list ที่มีการตั้งค่าพารามิเตอร์ mine เป็น true เพื่อเรียกข้อมูลรหัสเพลย์ลิสต์ที่ระบุวิดีโอของช่องที่อัปโหลดด้วย

ตัวอย่างนี้ใช้ไลบรารีของไคลเอ็นต์ 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

ข้อผิดพลาด

ตารางต่อไปนี้ระบุข้อความแสดงข้อผิดพลาดที่ API อาจแสดงผลเพื่อตอบสนองต่อการเรียกเมธอดนี้ โปรดดูรายละเอียดเพิ่มเติมในเอกสารประกอบข้อความแสดงข้อผิดพลาด

ประเภทข้อผิดพลาด	รายละเอียดข้อผิดพลาด	คำอธิบาย
forbidden (403)	playlistItemsNotAccessible	คำขอไม่ได้รับอนุญาตอย่างถูกต้องในการดึงข้อมูลเพลย์ลิสต์ที่ระบุ
forbidden (403)	watchHistoryNotAccessible	ไม่สามารถเรียกดูข้อมูลประวัติการดูผ่าน API ได้
forbidden (403)	watchLaterNotAccessible	คุณไม่สามารถเรียกดูรายการในเพลย์ลิสต์ "ดูภายหลัง" ผ่าน API
notFound (404)	playlistNotFound	ไม่พบเพลย์ลิสต์ที่ระบุด้วยพารามิเตอร์ playlistId ของคำขอ
notFound (404)	videoNotFound	ไม่พบวิดีโอที่ระบุด้วยพารามิเตอร์ videoId ของคำขอ
required (400)	playlistIdRequired	คำขอสมัครใช้บริการไม่ได้ระบุค่าสำหรับพร็อพเพอร์ตี้ playlistId ที่จำเป็น
invalidValue (400)	playlistOperationUnsupported	API ไม่รองรับความสามารถในการแสดงรายการวิดีโอในเพลย์ลิสต์ที่ระบุ เช่น คุณแสดงรายการวิดีโอในเพลย์ลิสต์ดูภายหลังไม่ได้

ลองใช้เลย

ใช้ APIs Explorer เพื่อเรียกใช้ API นี้เพื่อดูคำขอและการตอบสนองของ API