Exporter vers YouTube en .NET C# (bibliothèques open source)
Utilisez le client .NET open source de Google pour envoyer un MP4 local sur votre chaîne YouTube. Cette application console demande un accès limité à l’envoi, définit la vidéo comme privée, désactive les notifications aux abonnés et affiche l’identifiant vidéo renvoyé par YouTube. L’acceptation de l’envoi et la fin du traitement vidéo sont deux résultats distincts.
Prérequis
Ce guide utilise Bash sous Linux et un navigateur sur le même ordinateur. Installez le SDK .NET 10 avec un correctif de sécurité à jour. L’exemple local a été vérifié avec le SDK 10.0.403 et le runtime 10.0.14. Le SDK inclut le runtime ; le runtime seul ne permet pas de créer ni de compiler un projet.
Vous avez également besoin d’un petit fichier MP4 lisible qui vous appartient ou que vous êtes
autorisé à envoyer, d’une chaîne YouTube et de son identifiant. Suivez les
instructions relatives à l’identifiant de chaîne de YouTube en vous
connectant en tant que propriétaire principal de la chaîne visée. Utilisez des noms de fichiers
UTF-8. Cette application envoie le fichier en tant que video/mp4 ; elle ne
convertit pas d’autres fichiers en vidéo et ne valide pas leurs codecs.
Suivez la configuration du projet et d’OAuth de Google pour activer YouTube Data API v3 dans un projet Google Cloud. Configurez l’écran de consentement et ajoutez votre compte Google comme utilisateur test lorsque l’application est en phase de test. Créez un client OAuth de type Desktop app et téléchargez son fichier JSON dans un emplacement privé hors de votre dépôt de code source. Une clé API n’autorise pas les envois.
Le flux OAuth pour ordinateur de Google utilise un navigateur et un serveur local à l’écoute des rappels. Cet exemple est destiné à une application locale interactive ; un serveur distant sans interface nécessite une conception distincte de l’autorisation. Lors du consentement, sélectionnez la chaîne YouTube visée, y compris le compte de marque le cas échéant. Un compte Google peut avoir plusieurs chaînes.
Configurer le client de l’API YouTube
Commencez dans un dossier accessible en écriture, hors d’un projet .NET existant. La protection
ci-dessous refuse toute configuration de projet parent afin qu’une version de SDK imposée ou des
paramètres de compilation hérités ne puissent pas modifier silencieusement cet exemple autonome.
Elle crée un dossier youtube-upload et laisse votre shell dans son répertoire
d’origine. Si le dossier existe déjà, il est conservé et la configuration s’arrête.
(
command -v dotnet >/dev/null || exit 1
parent=$(pwd -P)
while :; do
for name in global.json Directory.Build.props Directory.Build.targets Directory.Packages.props NuGet.Config nuget.config NuGet.config; do
if [ -e "$parent/$name" ]; then
printf 'Use a folder without parent .NET configuration: %s\n' "$parent/$name" >&2
exit 1
fi
done
[ "$parent" = / ] && break
parent=${parent%/*}
parent=${parent:-/}
done
dotnet --version &&
mkdir youtube-upload &&
cd youtube-upload &&
dotnet new console --framework net10.0 &&
dotnet add package Google.Apis.YouTube.v3 --version 1.78.0.4309 &&
dotnet build
)
Le package est le client YouTube Data API pour .NET de Google. Si la création, l’installation ou la compilation échoue, corrigez l’erreur signalée avant de continuer. Conservez les fichiers déjà créés ; ne collez pas le bloc de création sur un projet existant.
Envoyer des vidéos
Remplacez le fichier youtube-upload/Program.cs généré par ce programme complet. Il utilise
GoogleWebAuthorizationBroker et FileDataStore
pour obtenir et conserver l’autorisation de l’utilisateur. Un répertoire de jetons est associé à
la chaîne sélectionnée lors du consentement ; son nom ne sélectionne pas de chaîne.
using Google.Apis.Auth.OAuth2;
using Google.Apis.Auth.OAuth2.Responses;
using Google.Apis.Services;
using Google.Apis.Upload;
using Google.Apis.Util.Store;
using Google.Apis.YouTube.v3;
using Google.Apis.YouTube.v3.Data;
public static class Program
{
public static async Task<int> Main(string[] args)
{
if (args.Length != 5 || string.IsNullOrWhiteSpace(args[3]) ||
string.IsNullOrWhiteSpace(args[4]) || args[4].Length > 100)
{
Console.Error.WriteLine(
"Usage: client.json video.mp4 token-directory expected-channel-id title");
return 2;
}
if (!File.Exists(args[0]) || !File.Exists(args[1]))
{
Console.Error.WriteLine("OAuth client file or video is missing. No upload started.");
return 2;
}
try
{
using var clientFile = File.OpenRead(args[0]);
using var videoFile = File.OpenRead(args[1]);
using var deadline = new CancellationTokenSource(TimeSpan.FromMinutes(10));
var store = new FileDataStore(Path.GetFullPath(args[2]), true);
var cached = await store.GetAsync<TokenResponse>("channel-owner");
Console.Error.WriteLine(cached is null
? "Opening browser authorization. Select the intended YouTube channel."
: "Using saved authorization; no new channel selection was requested.");
var credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.FromStream(clientFile).Secrets,
new[] { YouTubeService.Scope.YoutubeUpload },
"channel-owner", deadline.Token, store);
var scopes = credential.Token.Scope?.Split(' ', StringSplitOptions.RemoveEmptyEntries);
if (scopes is null || scopes.Length != 1 ||
scopes[0] != YouTubeService.Scope.YoutubeUpload)
{
Console.Error.WriteLine("Expected upload-only consent. Use a fresh token directory.");
return 1;
}
using var youtube = new YouTubeService(new BaseClientService.Initializer
{
HttpClientInitializer = credential,
ApplicationName = "PrivateVideoUpload"
});
youtube.HttpClient.Timeout = TimeSpan.FromSeconds(60);
await UploadPrivateVideoAsync(youtube, videoFile, args[3], args[4], deadline.Token);
Console.WriteLine("Private upload accepted; processing may still be pending.");
return 0;
}
catch (Exception)
{
Console.Error.WriteLine(
"Upload failed or its outcome is unknown. Inspect the selected channel in " +
"YouTube Studio before retrying. Do not automatically repeat this upload.");
return 1;
}
}
public static async Task<string> UploadPrivateVideoAsync(
YouTubeService youtube, Stream source, string expectedChannelId,
string title, CancellationToken cancellationToken)
{
var video = new Video
{
Snippet = new VideoSnippet { Title = title, CategoryId = "22" },
Status = new VideoStatus { PrivacyStatus = "private" }
};
var upload = youtube.Videos.Insert(video, "snippet,status", source, "video/mp4");
upload.NotifySubscribers = false;
Console.Error.WriteLine($"Upload settings: privacy={video.Status.PrivacyStatus}; notifySubscribers={upload.NotifySubscribers}");
upload.ChunkSize = ResumableUpload.MinimumChunkSize;
upload.ProgressChanged += progress =>
{
if (progress.Status == UploadStatus.Uploading)
Console.Error.WriteLine($"Bytes sent: {progress.BytesSent}");
};
var progress = await upload.UploadAsync(cancellationToken);
progress.ThrowOnFailure();
var result = upload.ResponseBody;
if (progress.Status != UploadStatus.Completed || string.IsNullOrWhiteSpace(result?.Id))
throw new InvalidOperationException("No confirmed video ID was returned.");
Console.WriteLine($"Video ID: {result.Id}");
if (result.Snippet?.ChannelId != expectedChannelId || result.Snippet?.Title != title ||
result.Status?.PrivacyStatus != "private")
throw new InvalidOperationException("Returned video metadata did not match the upload.");
return result.Id;
}
}
Depuis le dossier de travail d’origine, exécutez la commande suivante après avoir remplacé les
cinq arguments. Choisissez un chemin de répertoire de jetons privé encore inutilisé pour la
première autorisation. La commande compile le programme enregistré avant de l’exécuter ;
-- sépare les arguments de l’application des options .NET.
dotnet run --project ./youtube-upload -- \
"/absolute/path/client.json" "/absolute/path/my video.mp4" \
"/absolute/private/path/youtube-channel-tokens" \
"YOUR_CHANNEL_ID" "My private upload"
Suivez le flux de consentement de Google dans le navigateur. Le programme demande uniquement
youtube.upload, l’un des champs d’application acceptés par
videos.insert. Il envoie explicitement
privacyStatus=private et notifySubscribers=false, dont la valeur par défaut serait
sinon true.
À l’acceptation, le programme affiche Video ID: suivi de l’identifiant réel. Enregistrez cet identifiant et examinez la vidéo dans YouTube Studio, sous la chaîne sélectionnée. L’argument d’identifiant de chaîne attendu sert à vérifier les métadonnées renvoyées après l’envoi, et non à sélectionner la destination ni à empêcher un envoi vers une chaîne autorisée par erreur. Si la vérification échoue, le programme se termine en échec, mais affiche l’identifiant renvoyé pour vous permettre de retrouver la vidéo.
Les octets envoyés indiquent la progression du transfert. Même un envoi terminé avec un
identifiant ne prouve pas que YouTube a fini de traiter une vidéo lisible. Vérifiez le traitement
dans YouTube Studio avant de publier ; Google documente un
processingDetails.processingStatus distinct pour cette phase.
Gérer les quotas et les limites de débit
Vérifiez les limites actuelles de votre projet dans Google Cloud et dans le
calculateur de quotas YouTube avant d’automatiser les envois.
Au 5 novembre 2026, la valeur par défaut documentée est un quota distinct de 100 appels
videos.insert par jour, auquel s’ajoutent des limites distinctes pour la recherche
et les autres points de terminaison. Les quotas quotidiens sont réinitialisés à minuit, heure du
Pacifique. Les requêtes non valides consomment aussi du quota.
Un compteur local ne peut pas tenir compte des autres processus, des redémarrages ni de toutes les requêtes du SDK. Cet exemple effectue une seule tentative d’insertion au niveau applicatif ; il n’implémente pas de planificateur de quotas à l’échelle du projet.
Gérer les échecs avant de réessayer
Un code de sortie non nul peut indiquer un refus, une annulation, un dépassement de délai ou une réponse perdue après l’acceptation de la vidéo par YouTube. L’application demande l’annulation de l’autorisation et de l’envoi après dix minutes et configure un délai d’expiration HTTP de 60 secondes par requête d’envoi. L’annulation est coopérative et ne garantit pas l’arrêt du processus ; une connexion lente peut interrompre un envoi par ailleurs valide. Aucun de ces délais ne prouve qu’une écriture distante a été annulée.
Le SDK utilise des requêtes d’envoi avec reprise, mais ce programme n’enregistre pas leur URI de
session pour permettre une reprise après la fin du processus. N’encadrez pas toute la commande
dotnet run dans une boucle de nouvelle tentative : un nouvel appel
videos.insert peut créer une seconde vidéo si la première réponse a été perdue.
Examinez la chaîne visée et tout identifiant vidéo affiché avant de décider de réessayer. La
seule progression affichée ne permet pas de déterminer une issue inconnue.
Garder l’autorisation liée à sa chaîne
FileDataStore conserve les jetons ; ce n’est pas un coffre chiffré de données
d’accès. Restreignez l’accès au fichier JSON du client et au répertoire de jetons, et gardez-les
tous deux hors du contrôle de version. La réutilisation du répertoire peut éviter l’ouverture du
navigateur : une exécution réussie utilisant le cache ne prouve donc pas qu’une nouvelle sélection
de chaîne a eu lieu. Pour autoriser une autre chaîne, choisissez un autre chemin de répertoire
de jetons privé encore inutilisé et effectuez à nouveau le consentement.
Vous disposez maintenant d’un point d’entrée console pour un envoi unique, dont le résultat confirmé est un identifiant de vidéo privée. Gardez la vidéo privée jusqu’à ce que vous ayez vérifié sa chaîne, son contenu et le résultat du traitement dans YouTube Studio. Pour connaître les champs de requête disponibles au-delà de cet exemple, consultez la référence officielle des envois.
Vous préférez ne pas l’exécuter vous-même ?
Transloadit exporte des fichiers vers S3, Azure, Google Cloud et d’autres destinations, comme étape d’un seul appel API.
