Videos: insert

Przesyła film do YouTube i opcjonalnie ustawia metadane filmu.

Ta metoda obsługuje przesyłanie multimediów. Przesłane pliki muszą spełniać te ograniczenia:

• Maksymalny rozmiar pliku: 256 GB
• Akceptowane typy MIME multimediów: video/*, application/octet-stream

Wpływ na limit: 100 wywołań dziennie. Wywołanie tej metody wiąże się z kosztem limitu 1 jednostki w ramach limitu przesyłania filmów.

Częste zastosowania

Żądanie

Żądanie HTTP

POST https://www.googleapis.com/upload/youtube/v3/videos

Autoryzacja

To żądanie wymaga autoryzacji z co najmniej jednym z tych zakresów (więcej informacji o uwierzytelnianiu i autoryzacji).

Zakres
https://www.googleapis.com/auth/youtube.upload
https://www.googleapis.com/auth/youtube
https://www.googleapis.com/auth/youtubepartner
https://www.googleapis.com/auth/youtube.force-ssl

Parametry

W tabeli poniżej znajdziesz listę parametrów obsługiwanych przez to zapytanie. Wszystkie wymienione parametry to parametry zapytania.

Parametry
Parametry wymagane
part	string Parametr part pełni w tej operacji 2 funkcje. Określa właściwości, które zostaną ustawione przez operację zapisu, oraz właściwości, które zostaną uwzględnione w odpowiedzi interfejsu API. Pamiętaj, że nie wszystkie części zawierają właściwości, które można ustawić podczas wstawiania lub aktualizowania filmu. Na przykład obiekt statistics zawiera statystyki obliczane przez YouTube dla filmu i nie zawiera wartości, które można ustawić lub zmodyfikować. Jeśli wartość parametru określa part, która nie zawiera wartości podlegających zmianie, ta part nadal będzie uwzględniana w odpowiedzi interfejsu API. Poniżej znajdziesz listę nazw part, które możesz uwzględnić w wartości parametru: brandPartner contentDetails fileDetails id liveStreamingDetails localizations paidProductPlacementDetails player processingDetails recordingDetails snippet statistics status suggestions topicDetails
Parametry opcjonalne
notifySubscribers	boolean Parametr notifySubscribers określa, czy YouTube ma wysyłać powiadomienia o nowych filmach użytkownikom, którzy subskrybują kanał filmu. Wartość parametru True oznacza, że subskrybenci będą otrzymywać powiadomienia o nowo przesłanych filmach. Właściciel kanału, który przesyła wiele filmów, może jednak ustawić wartość False, aby uniknąć wysyłania powiadomień o każdym nowym filmie do subskrybentów kanału. Wartość domyślna to True.
onBehalfOfContentOwner	string Ten parametr może być używany tylko w prawidłowo autoryzowanym żądaniu. Uwaga: ten parametr jest przeznaczony wyłącznie dla partnerów YouTube. Parametr onBehalfOfContentOwner wskazuje, że dane uwierzytelniające autoryzację żądania identyfikują użytkownika systemu CMS YouTube, który działa w imieniu właściciela treści określonego w wartości parametru. Parametr `**onBehalfOfContentOwner**` wskazuje, że dane uwierzytelniające żądania identyfikują użytkownika systemu zarządzania treścią w YouTube, który działa w imieniu właściciela treści określonego w wartości parametru. Umożliwia to właścicielom treści jednokrotne uwierzytelnienie i uzyskanie dostępu do wszystkich danych dotyczących ich filmów i kanałów bez konieczności podawania danych uwierzytelniających dla każdego pojedynczego kanału. Konto CMS, za pomocą którego uwierzytelnia się użytkownik, musi być połączone z określonym właścicielem treści w YouTube.
onBehalfOfContentOwnerChannel	string Ten parametr może być używany tylko w prawidłowo autoryzowanym żądaniu. `string` Ten parametr może być używany tylko w prawidłowo autoryzowanym żądaniu. Uwaga: ten parametr jest przeznaczony wyłącznie dla partnerów YouTube. Parametr onBehalfOfContentOwnerChannel określa identyfikator kanału YouTube, do którego dodawany jest film. Ten parametr jest wymagany, gdy żądanie określa wartość parametru onBehalfOfContentOwner, i może być używany tylko w połączeniu z tym parametrem. Ponadto żądanie musi być autoryzowane przy użyciu konta CMS, które jest połączone z właścicielem treści określonym przez parametr onBehalfOfContentOwner. Ponadto żądanie musi być autoryzowane za pomocą konta CMS onBehalfOfContentOwnerChannel połączonego z właścicielem treści określonym w parametrze onBehalfOfContentOwner. Umożliwia to właścicielom treści jednokrotne uwierzytelnienie i wykonywanie działań w imieniu kanału określonego w wartości parametru, bez konieczności podawania danych uwierzytelniających dla każdego oddzielnego kanału.

Umożliwia on właścicielom treści jednorazowe uwierzytelnienie i wykonywanie działań w imieniu kanału określonego w wartości parametru bez konieczności podawania danych uwierzytelniających dla każdego kanału.

Treść żądania zawiera zasób wideo. W treści żądania podaj zasób video.

• W przypadku tego zasobu możesz ustawić wartości tych właściwości:

  • snippet.title
  • snippet.description
  • snippet.tags[]
  • snippet.categoryId
  • snippet.defaultLanguage
  • localizations.(key)
  • localizations.(key).title
  • localizations.(key).description
  • status.embeddable
  • status.license
  • status.privacyStatus: jeśli nie określisz wartości tej właściwości, domyślnie ustawiona zostanie wartość public. W przypadku niektórych przesyłanych treści domyślnie może być ustawiona wartość private zgodnie z ustawieniami konta twórcy, jak wyjaśniono w Centrum pomocy YouTube. Filmy przesłane z niezweryfikowanych projektów API nie są ograniczone do trybu prywatnego.
  • status.publicStatsViewable
  • status.publishAt
  • status.selfDeclaredMadeForKids
  • status.containsSyntheticMedia
  • recordingDetails.recordingDate

Odpowiedź

Jeśli operacja się uda, ta metoda zwróci w treści odpowiedzi zasób video.

Przykłady

Uwaga: poniższe przykłady kodu mogą nie odzwierciedlać wszystkich obsługiwanych języków programowania. Listę obsługiwanych języków znajdziesz w dokumentacji bibliotek klienta.

Go

Ten przykładowy kod wywołuje metodę videos.insert interfejsu API, aby przesłać film na kanał powiązany z żądaniem.

Ten przykład korzysta z biblioteki klienta Go.

package main

import (
	"flag"
	"fmt"
	"log"
	"os"
	"strings"

	"google.golang.org/api/youtube/v3"
)

var (
	filename    = flag.String("filename", "", "Name of video file to upload")
	title       = flag.String("title", "Test Title", "Video title")
	description = flag.String("description", "Test Description", "Video description")
	category    = flag.String("category", "22", "Video category")
	keywords    = flag.String("keywords", "", "Comma separated list of video keywords")
	privacy     = flag.String("privacy", "unlisted", "Video privacy status")
)

func main() {
	flag.Parse()

	if *filename == "" {
		log.Fatalf("You must provide a filename of a video file to upload")
	}

	client := getClient(youtube.YoutubeUploadScope)

	service, err := youtube.New(client)
	if err != nil {
		log.Fatalf("Error creating YouTube client: %v", err)
	}

	upload := &youtube.Video{
		Snippet: &youtube.VideoSnippet{
			Title:       *title,
			Description: *description,
			CategoryId:  *category,
		},
		Status: &youtube.VideoStatus{PrivacyStatus: *privacy},
	}

	// The API returns a 400 Bad Request response if tags is an empty string.
	if strings.Trim(*keywords, "") != "" {
		upload.Snippet.Tags = strings.Split(*keywords, ",")
	}

	call := service.Videos.Insert("snippet,status", upload)

	file, err := os.Open(*filename)
	defer file.Close()
	if err != nil {
		log.Fatalf("Error opening %v: %v", *filename, err)
	}

	response, err := call.Media(file).Do()
	handleError(err, "")
	fmt.Printf("Upload successful! Video ID: %v\n", response.Id)
}
upload_video.go

.NET

Ten przykładowy kod wywołuje metodę videos.insert interfejsu API, aby przesłać film na kanał powiązany z żądaniem.

Ten przykład korzysta z biblioteki klienta.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: upload a video.
  /// 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 UploadVideo
  {
    [STAThread]
    static void Main(string[] args)
    {
      Console.WriteLine("YouTube Data API: Upload Video");
      Console.WriteLine("==============================");

      try
      {
        new UploadVideo().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 an application to upload files to the
            // authenticated user's YouTube channel, but doesn't allow other types of access.
            new[] { YouTubeService.Scope.YoutubeUpload },
            "user",
            CancellationToken.None
        );
      }

      var youtubeService = new YouTubeService(new BaseClientService.Initializer()
      {
        HttpClientInitializer = credential,
        ApplicationName = Assembly.GetExecutingAssembly().GetName().Name
      });

      var video = new Video();
      video.Snippet = new VideoSnippet();
      video.Snippet.Title = "Default Video Title";
      video.Snippet.Description = "Default Video Description";
      video.Snippet.Tags = new string[] { "tag1", "tag2" };
      video.Snippet.CategoryId = "22"; // See https://developers.google.com/youtube/v3/docs/videoCategories/list
      video.Status = new VideoStatus();
      video.Status.PrivacyStatus = "unlisted"; // or "private" or "public"
      var filePath = @"REPLACE_ME.mp4"; // Replace with path to actual movie file.

      using (var fileStream = new FileStream(filePath, FileMode.Open))
      {
        var videosInsertRequest = youtubeService.Videos.Insert(video, "snippet,status", fileStream, "video/*");
        videosInsertRequest.ProgressChanged += videosInsertRequest_ProgressChanged;
        videosInsertRequest.ResponseReceived += videosInsertRequest_ResponseReceived;

        await videosInsertRequest.UploadAsync();
      }
    }

    void videosInsertRequest_ProgressChanged(Google.Apis.Upload.IUploadProgress progress)
    {
      switch (progress.Status)
      {
        case UploadStatus.Uploading:
          Console.WriteLine("{0} bytes sent.", progress.BytesSent);
          break;

        case UploadStatus.Failed:
          Console.WriteLine("An error prevented the upload from completing.\n{0}", progress.Exception);
          break;
      }
    }

    void videosInsertRequest_ResponseReceived(Video video)
    {
      Console.WriteLine("Video id '{0}' was successfully uploaded.", video.Id);
    }
  }
}
UploadVideo.cs

Ruby

Ten przykład wywołuje metodę videos.insert interfejsu API, aby przesłać film na kanał powiązany z żądaniem.

Ten przykład korzysta z biblioteki klienta 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'
require 'trollop'

# A limited OAuth 2 access scope that allows for uploading files, but not other
# types of account access.
YOUTUBE_UPLOAD_SCOPE = 'https://www.googleapis.com/auth/youtube.upload'
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_UPLOAD_SCOPE]
    )
    client.authorization = flow.authorize(file_storage)
  else
    client.authorization = file_storage.authorization
  end

  return client, youtube
end

def main
  opts = Trollop::options do
    opt :file, 'Video file to upload', :type => String
    opt :title, 'Video title', :default => 'Test Title', :type => String
    opt :description, 'Video description',
          :default => 'Test Description', :type => String
    opt :category_id, 'Numeric video category. See https://developers.google.com/youtube/v3/docs/videoCategories/list',
          :default => 22, :type => :int
    opt :keywords, 'Video keywords, comma-separated',
          :default => '', :type => String
    opt :privacy_status, 'Video privacy status: public, private, or unlisted',
          :default => 'public', :type => String
  end

  if opts[:file].nil? or not File.file?(opts[:file])
    Trollop::die :file, 'does not exist'
  end

  client, youtube = get_authenticated_service

  begin
    body = {
      :snippet => {
        :title => opts[:title],
        :description => opts[:description],
        :tags => opts[:keywords].split(','),
        :categoryId => opts[:category_id],
      },
      :status => {
        :privacyStatus => opts[:privacy_status]
      }
    }

    videos_insert_response = client.execute!(
      :api_method => youtube.videos.insert,
      :body_object => body,
      :media => Google::APIClient::UploadIO.new(opts[:file], 'video/*'),
      :parameters => {
        :uploadType => 'resumable',
        :part => body.keys.join(',')
      }
    )

    videos_insert_response.resumable_upload.send_all(client)

    puts "Video id '#{videos_insert_response.data.id}' was successfully uploaded."
  rescue Google::APIClient::TransmissionError => e
    puts e.result.body
  end
end

main
upload_video.rb

Błędy

W tabeli poniżej znajdziesz komunikaty o błędach, które interfejs API może zwrócić w odpowiedzi na wywołanie tej metody. Więcej informacji znajdziesz w dokumentacji komunikatów o błędach.

Typ błędu	Szczegóły błędu	Opis
badRequest (400)	defaultLanguageNotSet	Żądanie próbuje dodać zlokalizowane szczegóły filmu bez określania domyślnego języka szczegółów filmu.
badRequest (400)	invalidCategoryId	Właściwość snippet.categoryId określa nieprawidłowy identyfikator kategorii. Aby pobrać obsługiwane kategorie, użyj metody videoCategories.list.
badRequest (400)	invalidDescription	Metadane żądania określają nieprawidłowy opis filmu.
badRequest (400)	invalidFilename	Nazwa pliku wideo określona w nagłówku Slug jest nieprawidłowa.
badRequest (400)	invalidPublishAt	Metadane żądania określają nieprawidłowy zaplanowany czas publikacji.
badRequest (400)	invalidRecordingDetails	Obiekt recordingDetails w metadanych żądania określa nieprawidłowe szczegóły nagrania.
badRequest (400)	invalidTags	Metadane żądania określają nieprawidłowe słowa kluczowe filmu.
badRequest (400)	invalidTitle	Metadane żądania określają nieprawidłowy lub pusty tytuł filmu.
badRequest (400)	invalidVideoGameRating	Metadane żądania określają nieprawidłową ocenę gry wideo.
badRequest (400)	invalidVideoMetadata	Metadane żądania są nieprawidłowe.
badRequest (400)	mediaBodyRequired	Żądanie nie zawiera treści wideo.
badRequest (400)	uploadLimitExceeded	Użytkownik przekroczył liczbę filmów, które może przesłać.
forbidden (403)	forbidden
forbidden (403)	forbiddenLicenseSetting	Żądanie próbuje ustawić nieprawidłową licencję na film.
forbidden (403)	forbiddenPrivacySetting	Żądanie próbuje ustawić nieprawidłowe ustawienie prywatności filmu.

Wypróbuj

Aby wywołać ten interfejs API i zobaczyć żądanie do interfejsu API oraz odpowiedź, użyj APIs Explorer.