Playlists: insert

재생목록을 만듭니다. 지금 사용해 보거나 예를 참조하세요.





이 요청에는 다음 범위 중 최소 하나를 사용하여 인증이 필요합니다. (인증 및 승인에 대해 자세히 알아보기)



아래 표는 이 쿼리가 지원하는 매개변수 목록입니다. 나열된 모든 매개변수는 쿼리 매개변수입니다.

매개변수 이름
필수 매개변수
part string
part 매개변수는 이 연산에서 2가지 용도로 사용됩니다. 쓰기 연산에서 설정하는 속성과 API 응답에서 포함하는 속성을 식별합니다.

매개변수 값에 포함할 수 있는 part 이름은 snippetstatus입니다.

요청 본문

요청 본문에 playlist 리소스를 제공합니다. 이 리소스의 경우

  • 다음 속성에 값을 지정해야 합니다.

    • snippet.title

  • 다음 속성에 값을 설정할 수 있습니다.

    • snippet.title
    • snippet.description
    • status.privacyStatus
    • snippet.tags[]


성공하는 경우 이 메소드는 응답 본문에 playlist 리소스를 반환합니다.

참고: 아래의 코드 샘플은 지원되는 일부 프로그래밍 언어를 나타냅니다. 지원되는 언어 목록을 보려면 클라이언트 라이브러리 문서를 참조하세요.


Java 클라이언트 라이브러리를 사용하는 예입니다.


     * Copyright (c) 2012 Google Inc.
     * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
     * in compliance with the License. You may obtain a copy of the License at
     * Unless required by applicable law or agreed to in writing, software distributed under the
     * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
     * express or implied. See the License for the specific language governing permissions and
     * limitations under the License.
    import java.util.Calendar;
    import java.util.List;
     * Creates a new, private playlist in the authorized user's channel and adds a playlistitem
     * containing a video to that new playlist.
     * @author Jeremy Walker
    public class PlaylistUpdates {
      /** Global instance of the HTTP transport. */
      private static final HttpTransport HTTP_TRANSPORT = new NetHttpTransport();
      /** Global instance of the JSON factory. */
      private static final JsonFactory JSON_FACTORY = new JacksonFactory();
      /** Global instance of YouTube object to make all API requests. */
      private static YouTube youtube;
       * Global instance of the video id we want to post as the first PlaylistItem in our new playlist.
      private static String VIDEO_ID = "SZj6rAYkYOg";
       * Authorizes the installed application to access user's protected data.
       * @param scopes list of scopes needed to run upload.
      private static Credential authorize(List<String> scopes) throws Exception {
        // Load client secrets.
        GoogleClientSecrets clientSecrets =
        // Checks that the defaults have been replaced (Default = "Enter X here").
        if (clientSecrets.getDetails().getClientId().startsWith("Enter")
            || clientSecrets.getDetails().getClientSecret().startsWith("Enter ")) {
              "Enter Client ID and Secret from"
              + "into youtube-cmdline-playlistupdates-sample/src/main/resources/client_secrets.json");
        // Set up file credential store.
        FileCredentialStore credentialStore =
            new FileCredentialStore(
                new File(System.getProperty("user.home"),
        // Set up authorization code flow.
        GoogleAuthorizationCodeFlow flow = 
            new GoogleAuthorizationCodeFlow.Builder(HTTP_TRANSPORT, 
        // Build the local server and bind it to port 9000
        LocalServerReceiver localReceiver = new LocalServerReceiver.Builder().setPort(8080).build();
        // Authorize.
        return new AuthorizationCodeInstalledApp(flow, localReceiver).authorize("user");
       * Authorizes user, creates a playlist, adds a playlistitem with a video to that new playlist.
       * @param args command line args (not used).
      public static void main( String[] args ) {
        // General read/write scope for YouTube APIs.
        List<String> scopes = Lists.newArrayList("");
        try {
          // Authorization.
          Credential credential = authorize(scopes);
          // YouTube object used to make all API requests.
          youtube = new YouTube.Builder(HTTP_TRANSPORT, JSON_FACTORY, credential)
          // Creates a new playlist in the authorized user's channel.
          String playlistId = insertPlaylist();
          // If a valid playlist was created, adds a new playlistitem with a video to that playlist.
          insertPlaylistItem(playlistId, VIDEO_ID);
        } catch (GoogleJsonResponseException e) {
          System.err.println("There was a service error: " + e.getDetails().getCode() + " : " + e.getDetails().getMessage());
        } catch (IOException e) {
          System.err.println("IOException: " + e.getMessage());
        } catch (Throwable t) {
          System.err.println("Throwable: " + t.getMessage());
       * Creates YouTube Playlist and adds it to the authorized account.
      private static String insertPlaylist() throws IOException {
         * We need to first create the parts of the Playlist before the playlist itself.  Here we are
         * creating the PlaylistSnippet and adding the required data.
        PlaylistSnippet playlistSnippet = new PlaylistSnippet();
        playlistSnippet.setTitle("Test Playlist " + Calendar.getInstance().getTime());
        playlistSnippet.setDescription("A private playlist created with the YouTube API v3");
        // Here we set the privacy status (required).
        PlaylistStatus playlistStatus = new PlaylistStatus();
         * Now that we have all the required objects, we can create the Playlist itself and assign the
         * snippet and status objects from above.
        Playlist youTubePlaylist = new Playlist();
         * This is the object that will actually do the insert request and return the result.  The
         * first argument tells the API what to return when a successful insert has been executed.  In
         * this case, we want the snippet and contentDetails info.  The second argument is the playlist
         * we wish to insert.
        YouTube.Playlists.Insert playlistInsertCommand =
            youtube.playlists().insert("snippet,status", youTubePlaylist);
        Playlist playlistInserted = playlistInsertCommand.execute();
        // Pretty print results.
        System.out.println("New Playlist name: " + playlistInserted.getSnippet().getTitle());
        System.out.println(" - Privacy: " + playlistInserted.getStatus().getPrivacyStatus());
        System.out.println(" - Description: " + playlistInserted.getSnippet().getDescription());
        System.out.println(" - Posted: " + playlistInserted.getSnippet().getPublishedAt());
        System.out.println(" - Channel: " + playlistInserted.getSnippet().getChannelId() + "\n");
        return playlistInserted.getId();
       * Creates YouTube PlaylistItem with specified video id and adds it to the specified playlist id
       * for the authorized account.
       * @param playlistId assign to newly created playlistitem
       * @param videoId YouTube video id to add to playlistitem
      private static String insertPlaylistItem(String playlistId, String videoId) throws IOException {
         * The Resource type (video,playlist,channel) needs to be set along with the resource id. In
         * this case, we are setting the resource to a video id, since that makes sense for this
         * playlist.
        ResourceId resourceId = new ResourceId();
         * Here we set all the information required for the snippet section.  We also assign the
         * resource id from above to the snippet object.
        PlaylistItemSnippet playlistItemSnippet = new PlaylistItemSnippet();
        playlistItemSnippet.setTitle("First video in the test playlist");
         * Now that we have all the required objects, we can create the PlaylistItem itself and assign
         * the snippet object from above.
        PlaylistItem playlistItem = new PlaylistItem();
         * This is the object that will actually do the insert request and return the result.  The
         * first argument tells the API what to return when a successful insert has been executed.  In
         * this case, we want the snippet and contentDetails info.  The second argument is the
         * playlistitem we wish to insert.
        YouTube.PlaylistItems.Insert playlistItemsInsertCommand =
            youtube.playlistItems().insert("snippet,contentDetails", playlistItem);
        PlaylistItem returnedPlaylistItem = playlistItemsInsertCommand.execute();
        // Pretty print results.
        System.out.println("New PlaylistItem name: " + returnedPlaylistItem.getSnippet().getTitle());
        System.out.println(" - Video id: " + returnedPlaylistItem.getSnippet().getResourceId().getVideoId());
        System.out.println(" - Posted: " + returnedPlaylistItem.getSnippet().getPublishedAt());
        System.out.println(" - Channel: " + returnedPlaylistItem.getSnippet().getChannelId());
        return returnedPlaylistItem.getId();
  • pom.xml

    <project xmlns="" xmlns:xsi=""
        <!-- YouTube Data V3 support -->
          <!-- Forces Maven to use Java 1.6 -->
  • client_secrets.json

      "installed": {
        "client_id": "Enter Client ID",
        "client_secret": "Enter Client Secret"


JavaScript 클라이언트 라이브러리를 사용하는 예입니다.

// Define some variables used to remember state.
var playlistId, channelId;

// After the API loads, call a function to enable the playlist creation form.
function handleAPILoaded() {

// Enable the form for creating a playlist.
function enableForm() {
  $('#playlist-button').attr('disabled', false);

// Create a private playlist.
function createPlaylist() {
  var request ={
    part: 'snippet,status',
    resource: {
      snippet: {
        title: 'Test Playlist',
        description: 'A private playlist created with the YouTube API'
      status: {
        privacyStatus: 'private'
  request.execute(function(response) {
    var result = response.result;
    if (result) {
      playlistId =;
    } else {
      $('#status').html('Could not create playlist');

// Add a video ID specified in the form to the playlist.
function addVideoToPlaylist() {

// Add a video to a playlist. The "startPos" and "endPos" values let you
// start and stop the video at specific times when the video is played as
// part of the playlist. However, these values are not set in this example.
function addToPlaylist(id, startPos, endPos) {
  var details = {
    videoId: id,
    kind: 'youtube#video'
  if (startPos != undefined) {
    details['startAt'] = startPos;
  if (endPos != undefined) {
    details['endAt'] = endPos;
  var request ={
    part: 'snippet',
    resource: {
      snippet: {
        playlistId: playlistId,
        resourceId: details
  request.execute(function(response) {
    $('#status').html('<pre>' + JSON.stringify(response.result) + '</pre>');


.NET 클라이언트 라이브러리를 사용하는 예입니다.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;

 * External dependencies, OAuth 2.0 support, and core client libraries are at:
 * Also see the file for the Google.Apis.Samples.Helper classes at:

using DotNetOpenAuth.OAuth2;

using Google.Apis.Authentication;
using Google.Apis.Authentication.OAuth2;
using Google.Apis.Authentication.OAuth2.DotNetOpenAuth;
using Google.Apis.Samples.Helper;
using Google.Apis.Services;
using Google.Apis.Util;
using Google.Apis.Youtube.v3;
using Google.Apis.Youtube.v3.Data;

namespace dotnet
  class playlist_updates
    static void Main(string[] args)
      CommandLine.DisplayGoogleSampleHeader("YouTube Data API: Playlist Updates");

      var credentials = PromptingClientCredentials.EnsureFullClientCredentials();
      var provider = new NativeApplicationClient(GoogleAuthenticationServer.Description)
        ClientIdentifier = credentials.ClientId,
        ClientSecret = credentials.ClientSecret
      var auth = new OAuth2Authenticator<NativeApplicationClient>(provider, GetAuthorization);

      var youtube = new YoutubeService(new BaseClientService.Initializer()
        Authenticator = auth

      var newPlaylist = new Playlist();
      newPlaylist.Snippet = new PlaylistSnippet();
      newPlaylist.Snippet.Title = "Test Playlist";
      newPlaylist.Snippet.Description = "A playlist created with the YouTube API v3";
      newPlaylist.Status = new PlaylistStatus();
      newPlaylist.Status.PrivacyStatus = "public";
      newPlaylist = youtube.Playlists.Insert(newPlaylist, "snippet,status").Fetch();

      var newPlaylistItem = new PlaylistItem();
      newPlaylistItem.Snippet = new PlaylistItemSnippet();
      newPlaylistItem.Snippet.PlaylistId = newPlaylist.Id;
      newPlaylistItem.Snippet.ResourceId = new ResourceId();
      newPlaylistItem.Snippet.ResourceId.Kind = "youtube#video";
      newPlaylistItem.Snippet.ResourceId.VideoId = "GNRMeaz6QRI";
      newPlaylistItem = youtube.PlaylistItems.Insert(newPlaylistItem, "snippet").Fetch();

      CommandLine.WriteLine(String.Format("Playlist item id {0} was added to playlist id {1}.", newPlaylistItem.Id, newPlaylist.Id));


    private static IAuthorizationState GetAuthorization(NativeApplicationClient client)
      var storage = MethodBase.GetCurrentMethod().DeclaringType.ToString();
      var key = "storage_key";

      IAuthorizationState state = AuthorizationMgr.GetCachedRefreshToken(storage, key);
      if (state != null)
        state = AuthorizationMgr.RequestNativeAuthorization(client, YoutubeService.Scopes.Youtube.GetStringValue());
        AuthorizationMgr.SetCachedRefreshToken(storage, key, state);

      return state;


PHP 클라이언트 라이브러리를 사용하는 예입니다.


 * Library Requirements
 * 1. Install composer (
 * 2. On the command line, change to this directory (api-samples/php)
 * 3. Require the google/apiclient library
 *    $ composer require google/apiclient:~2.0
if (!file_exists(__DIR__ . '/vendor/autoload.php')) {
  throw new \Exception('please run "composer require google/apiclient:~2.0" in "' . __DIR__ .'"');

require_once __DIR__ . '/vendor/autoload.php';

 * You can acquire an OAuth 2.0 client ID and client secret from the
 * Google API Console <>
 * For more information about using OAuth 2.0 to access Google APIs, please see:
 * <>
 * Please ensure that you have enabled the YouTube Data API for your project.

$client = new Google_Client();
$redirect = filter_var('http://' . $_SERVER['HTTP_HOST'] . $_SERVER['PHP_SELF'],

// Define an object that will be used to make all API requests.
$youtube = new Google_Service_YouTube($client);

// Check if an auth token exists for the required scopes
$tokenSessionKey = 'token-' . $client->prepareScopes();
if (isset($_GET['code'])) {
  if (strval($_SESSION['state']) !== strval($_GET['state'])) {
    die('The session state did not match.');

  $_SESSION[$tokenSessionKey] = $client->getAccessToken();
  header('Location: ' . $redirect);

if (isset($_SESSION[$tokenSessionKey])) {

// Check to ensure that the access token was successfully acquired.
if ($client->getAccessToken()) {
  try {
    // This code creates a new, private playlist in the authorized user's
    // channel and adds a video to the playlist.

    // 1. Create the snippet for the playlist. Set its title and description.
    $playlistSnippet = new Google_Service_YouTube_PlaylistSnippet();
    $playlistSnippet->setTitle('Test Playlist  ' . date("Y-m-d H:i:s"));
    $playlistSnippet->setDescription('A private playlist created with the YouTube API v3');

    // 2. Define the playlist's status.
    $playlistStatus = new Google_Service_YouTube_PlaylistStatus();

    // 3. Define a playlist resource and associate the snippet and status
    // defined above with that resource.
    $youTubePlaylist = new Google_Service_YouTube_Playlist();

    // 4. Call the playlists.insert method to create the playlist. The API
    // response will contain information about the new playlist.
    $playlistResponse = $youtube->playlists->insert('snippet,status',
        $youTubePlaylist, array());
    $playlistId = $playlistResponse['id'];

    // 5. Add a video to the playlist. First, define the resource being added
    // to the playlist by setting its video ID and kind.
    $resourceId = new Google_Service_YouTube_ResourceId();

    // Then define a snippet for the playlist item. Set the playlist item's
    // title if you want to display a different value than the title of the
    // video being added. Add the resource ID and the playlist ID retrieved
    // in step 4 to the snippet as well.
    $playlistItemSnippet = new Google_Service_YouTube_PlaylistItemSnippet();
    $playlistItemSnippet->setTitle('First video in the test playlist');

    // Finally, create a playlistItem resource and add the snippet to the
    // resource, then call the playlistItems.insert method to add the playlist
    // item.
    $playlistItem = new Google_Service_YouTube_PlaylistItem();
    $playlistItemResponse = $youtube->playlistItems->insert(
        'snippet,contentDetails', $playlistItem, array());

    $htmlBody .= "<h3>New Playlist</h3><ul>";
    $htmlBody .= sprintf('<li>%s (%s)</li>',
    $htmlBody .= '</ul>';

    $htmlBody .= "<h3>New PlaylistItem</h3><ul>";
    $htmlBody .= sprintf('<li>%s (%s)</li>',
    $htmlBody .= '</ul>';

  } catch (Google_Service_Exception $e) {
    $htmlBody = sprintf('<p>A service error occurred: <code>%s</code></p>',
  } catch (Google_Exception $e) {
    $htmlBody = sprintf('<p>An client error occurred: <code>%s</code></p>',

  $_SESSION[$tokenSessionKey] = $client->getAccessToken();
} elseif ($OAUTH2_CLIENT_ID == 'REPLACE_ME') {
  $htmlBody = <<<END
  <h3>Client Credentials Required</h3>
    You need to set <code>\$OAUTH2_CLIENT_ID</code> and
    <code>\$OAUTH2_CLIENT_ID</code> before proceeding.
} else {
  // If the user hasn't authorized the app, initiate the OAuth flow
  $state = mt_rand();
  $_SESSION['state'] = $state;

  $authUrl = $client->createAuthUrl();
  $htmlBody = <<<END
  <h3>Authorization Required</h3>
  <p>You need to <a href="$authUrl">authorize access</a> before proceeding.<p>

<!doctype html>
<title>New Playlist</title>


Python 클라이언트 라이브러리를 사용하는 예입니다.


import httplib2
import os
import sys

from apiclient.discovery import build
from apiclient.errors import HttpError
from oauth2client.client import flow_from_clientsecrets
from oauth2client.file import Storage
from import argparser, run_flow

# The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
# the OAuth 2.0 information for this application, including its client_id and
# client_secret. You can acquire an OAuth 2.0 client ID and client secret from
# the Google API Console at
# Please ensure that you have enabled the YouTube Data API for your project.
# For more information about using OAuth2 to access the YouTube Data API, see:
# For more information about the client_secrets.json file format, see:
CLIENT_SECRETS_FILE = "client_secrets.json"

# This variable defines a message to display if the CLIENT_SECRETS_FILE is
# missing.
WARNING: Please configure OAuth 2.0

To make this sample run you will need to populate the client_secrets.json file
found at:


with information from the API Console

For more information about the client_secrets.json file format, please visit:
""" % os.path.abspath(os.path.join(os.path.dirname(__file__),

# This OAuth 2.0 access scope allows for full read/write access to the
# authenticated user's account.

flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE,

storage = Storage("%s-oauth2.json" % sys.argv[0])
credentials = storage.get()

if credentials is None or credentials.invalid:
  flags = argparser.parse_args()
  credentials = run_flow(flow, storage, flags)


# This code creates a new, private playlist in the authorized user's channel.
playlists_insert_response = youtube.playlists().insert(
      title="Test Playlist",
      description="A private playlist created with the YouTube API v3"

print "New playlist id: %s" % playlists_insert_response["id"]


아래 표에서는 이 메소드에 대한 호출에 응답하기 위해 API가 반환할 수 있는 오류 메시지를 식별합니다. 자세한 내용은 오류 메시지 설명서를 참조하세요.

오류 유형 오류 세부정보 설명
invalidValue invalidPlaylistSnippet 요청에서 잘못된 재생목록 스니펫을 제공합니다.
required playlistTitleRequired 요청에서 재생목록의 제목을 지정해야 합니다.

직접 사용해 보세요!

API Explorer를 사용하여 실시간 데이터에서 이 메소드를 호출하고 API 요청 및 응답을 확인해 보세요.