Videos: insert

Toutes les vidéos importées via le point de terminaison videos.insert à partir de projets d'API non validés créés après le 28 juillet 2020 seront limitées au mode de visionnage privé. Pour lever cette restriction, chaque projet d'API doit faire l'objet d'un audit afin de vérifier qu'il respecte les Conditions d'utilisation. Pour en savoir plus, consultez l'historique des révisions de l'API.

Met en ligne une vidéo sur YouTube et définit éventuellement les métadonnées de la vidéo.

Cette méthode est compatible avec l'importation de contenus multimédias. Les fichiers importés doivent respecter les contraintes suivantes:

  • Taille maximale des fichiers:256 Go
  • Types MIME de médias acceptés:video/*, application/octet-stream

Impact sur les quotas:un appel à cette méthode entraîne un coût du quota de 1 600 unités.

Cas d'utilisation courants

Requête

Requête HTTP

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

Autorisation

Une autorisation est requise pour cette requête. Celle-ci doit inclure au moins l'un des champs d'application suivants. En savoir plus sur le processus d'authentification et d'autorisation

Champ d'application
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

Paramètres

Le tableau suivant répertorie les paramètres compatibles avec cette requête. Tous les paramètres répertoriés sont des paramètres de requête.

Paramètres
Paramètres obligatoires
part string
Le paramètre part a deux finalités dans cette opération. Il identifie les propriétés que l'opération d'écriture définira, ainsi que les propriétés que la réponse de l'API inclura.

Notez que toutes les parties ne contiennent pas de propriétés pouvant être définies lors de l'insertion ou de la mise à jour d'une vidéo. Par exemple, l'objet statistics encapsule les statistiques calculées par YouTube pour une vidéo et ne contient pas de valeurs que vous pouvez définir ou modifier. Si la valeur de paramètre spécifie un part qui ne contient pas de valeurs modifiables, ce part sera tout de même inclus dans la réponse de l'API.

La liste suivante contient les noms part que vous pouvez inclure dans la valeur du paramètre:
  • contentDetails
  • fileDetails
  • id
  • liveStreamingDetails
  • localizations
  • player
  • processingDetails
  • recordingDetails
  • snippet
  • statistics
  • status
  • suggestions
  • topicDetails
Paramètres facultatifs
notifySubscribers boolean
Le paramètre notifySubscribers indique si YouTube doit envoyer une notification concernant la nouvelle vidéo aux utilisateurs qui s'abonnent à la chaîne de la vidéo. La valeur True indique que les abonnés seront informés des nouvelles vidéos mises en ligne. Toutefois, un propriétaire de chaîne qui met en ligne de nombreuses vidéos peut préférer définir la valeur False pour éviter d'envoyer une notification aux abonnés à chaque nouvelle vidéo. La valeur par défaut est True.
onBehalfOfContentOwner string
Ce paramètre ne peut être utilisé que dans une demande autorisée correctement. Remarque:Ce paramètre est destiné exclusivement aux partenaires de contenu YouTube.

Le paramètre onBehalfOfContentOwner indique que les identifiants d'autorisation de la demande identifient un utilisateur du CMS YouTube qui agit au nom du propriétaire de contenu spécifié dans la valeur du paramètre. Ce paramètre est destiné aux partenaires de contenu YouTube qui possèdent et gèrent un grand nombre de chaînes YouTube. Il permet aux propriétaires de contenu de s'authentifier une seule fois et d'accéder à toutes les données de leurs vidéos et de leur chaîne, sans avoir à fournir d'identifiants d'authentification pour chaque chaîne. Le compte CMS avec lequel l'utilisateur s'authentifie doit être associé au propriétaire de contenu YouTube spécifié.
onBehalfOfContentOwnerChannel string
Ce paramètre ne peut être utilisé que dans une demande autorisée correctement. Ce paramètre ne peut être utilisé que dans une demande autorisée correctement. Remarque:Ce paramètre est destiné exclusivement aux partenaires de contenu YouTube.

Le paramètre onBehalfOfContentOwnerChannel spécifie l'ID de la chaîne YouTube à laquelle la vidéo est ajoutée. Ce paramètre est obligatoire lorsqu'une requête spécifie une valeur pour le paramètre onBehalfOfContentOwner. Il ne peut être utilisé qu'avec ce paramètre. En outre, la demande doit être autorisée à l'aide d'un compte CMS associé au propriétaire de contenu spécifié par le paramètre onBehalfOfContentOwner. Enfin, la chaîne indiquée par le paramètre onBehalfOfContentOwnerChannel doit être associée au propriétaire de contenu indiqué par le paramètre onBehalfOfContentOwner.

Ce paramètre est destiné aux partenaires de contenu YouTube qui possèdent et gèrent de nombreuses chaînes YouTube. Il permet aux propriétaires de contenu de s'authentifier une seule fois et d'effectuer des actions au nom de la chaîne spécifiée dans la valeur du paramètre, sans avoir à fournir d'identifiants d'authentification pour chaque canal.

Corps de la requête

Fournissez une ressource vidéo dans le corps de la requête. Pour cette ressource:

  • Vous pouvez définir des valeurs pour ces propriétés:

    • snippet.title
    • snippet.description
    • snippet.tags[]
    • snippet.categoryId
    • snippet.defaultLanguage
    • localizations.(key)
    • localizations.(key).title
    • localizations.(key).description
    • status.embeddable
    • status.license
    • status.privacyStatus
    • status.publicStatsViewable
    • status.publishAt
    • status.selfDeclaredMadeForKids
    • recordingDetails.locationDescription (obsolète)
    • recordingDetails.location.latitude (obsolète)
    • recordingDetails.location.longitude (obsolète)
    • recordingDetails.recordingDate

Réponse

Lorsque cette méthode fonctionne, elle renvoie une ressource vidéo dans le corps de la réponse.

Exemples

Remarque:Les exemples de code suivants peuvent ne pas représenter tous les langages de programmation compatibles. Consultez la documentation sur les bibliothèques clientes pour obtenir la liste des langages compatibles.

Go

Cet exemple de code appelle la méthode videos.insert de l'API pour importer une vidéo sur la chaîne associée à la requête.

Cet exemple utilise la bibliothèque cliente 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

L'exemple de code suivant appelle la méthode videos.insert de l'API pour importer une vidéo sur la chaîne associée à la requête.

Cet exemple utilise la bibliothèque cliente.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

Cet exemple appelle la méthode videos.insert de l'API pour importer une vidéo sur la chaîne associée à la requête.

Cet exemple utilise la bibliothèque cliente 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

Erreurs

Le tableau suivant identifie les messages d'erreur que l'API peut renvoyer en réponse à un appel de cette méthode. Pour en savoir plus, consultez la documentation sur les messages d'erreur.

Type d'erreur Détails de l'erreur Description
badRequest (400) defaultLanguageNotSet La demande tente d'ajouter des détails localisés sans spécifier la langue par défaut des détails de la vidéo.
badRequest (400) invalidCategoryId La propriété snippet.categoryId spécifie un ID de catégorie non valide. Utilisez la méthode videoCategories.list pour récupérer les catégories acceptées.
badRequest (400) invalidDescription Les métadonnées de la requête spécifient une description de vidéo non valide.
badRequest (400) invalidFilename Le nom de fichier vidéo spécifié dans l'en-tête Slug n'est pas valide.
badRequest (400) invalidPublishAt Les métadonnées de requête spécifient une heure de publication planifiée non valide.
badRequest (400) invalidRecordingDetails L'objet recordingDetails dans les métadonnées de la requête spécifie les détails de l'enregistrement non valides.
badRequest (400) invalidTags Les métadonnées de la requête spécifient des mots clés vidéo non valides.
badRequest (400) invalidTitle Les métadonnées de la requête spécifient un titre de vidéo non valide ou vide.
badRequest (400) invalidVideoGameRating Les métadonnées de la requête spécifient une classification de jeu vidéo non valide.
badRequest (400) invalidVideoMetadata Les métadonnées de la requête ne sont pas valides.
badRequest (400) mediaBodyRequired La demande n'inclut pas le contenu vidéo.
badRequest (400) uploadLimitExceeded L'utilisateur a dépassé le nombre maximal de vidéos qu'il peut mettre en ligne.
forbidden (403) forbidden
forbidden (403) forbiddenLicenseSetting La demande tente de définir une licence non valide pour la vidéo.
forbidden (403) forbiddenPrivacySetting La demande tente de définir un paramètre de confidentialité non valide pour la vidéo.

Essayer

Utilisez APIs Explorer pour appeler cette API et afficher la requête et la réponse de l'API.