PlaylistItems: list

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

ผลกระทบต่อโควต้า: การเรียกใช้วิธีการนี้มีโควต้า ซึ่งมี 1 หน่วย

กรณีการใช้งานทั่วไป

ส่งคำขอ

คำขอ 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 ระบุว่าข้อมูลเข้าสู่ระบบการให้สิทธิ์ของคําขอระบุผู้ใช้ CMS ของ YouTube ที่ทําหน้าที่ในนามของเจ้าของเนื้อหาที่ระบุในค่าพารามิเตอร์ พารามิเตอร์นี้มีไว้สําหรับพาร์ทเนอร์เนื้อหา 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