Adiciona uma inscrição para o canal do usuário autenticado. Faça um teste agora ou veja um exemplo.
Solicitação
Solicitação HTTP
POST https://www.googleapis.com/youtube/v3/subscriptions
Autorização
Esta solicitação requer autorização com pelo menos um dos seguintes escopos (saiba mais sobre autenticação e autorização).
Escopo |
---|
https://www.googleapis.com/auth/youtubepartner |
https://www.googleapis.com/auth/youtube |
Parâmetros
A tabela a seguir lista os parâmetros que esta consulta suporta. Todos os parâmetros listados são os parâmetros de consulta.
Parâmetros | ||
---|---|---|
Parâmetros obrigatórios | ||
part |
string O parâmetro part tem duas finalidades nesta operação: identifica as propriedades que serão definidas pela operação de gravação e as propriedades que serão incluídas pela resposta da API.Os nomes part que podem ser incluídos no valor do parâmetro são snippet e contentDetails . |
Corpo de solicitação
Forneça um recurso de inscrição no corpo da solicitação. Para esse recurso:
-
É necessário especificar um valor para essas propriedades:
snippet.resourceId
-
Você pode definir valores para estas propriedades:
snippet.resourceId
Resposta
Se for bem sucedido, este método retorna um recurso de inscrição no corpo da resposta.
Exemplos
Observação: os exemplos de código a seguir não representam todas as linguagens de programação suportadas. Consulte a documentação bibliotecas clientes para uma lista das linguagens suportadas.
Apps Script
O exemplo de código abaixo chama o método subscriptions.insert
da API para adicionar uma assinatura a um canal especificado.
/** * This sample subscribes the active user to the GoogleDevelopers * YouTube channel, specified by the channelId. */ function addSubscription() { // Replace this channel ID with the channel ID you want to subscribe to var channelId = 'UC9gFih9rw0zNCK3ZtoKQQyA'; var resource = { snippet: { resourceId: { kind: 'youtube#channel', channelId: channelId } } }; try { var response = YouTube.Subscriptions.insert(resource, 'snippet'); Logger.log(response); } catch (e) { if(e.message.match('subscriptionDuplicate')) { Logger.log('Cannot subscribe; already subscribed to channel: ' + channelId); } else { Logger.log('Error adding subscription: ' + e.message); } } }
Java
O exemplo de código abaixo chama o método subscriptions.insert
da API para adicionar uma assinatura a um canal especificado.
Este exemplo usa a biblioteca cliente Java.
/* * Copyright (c) 2013 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 * * http://www.apache.org/licenses/LICENSE-2.0 * * 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. */ package com.google.api.services.samples.youtube.cmdline.data; import com.google.api.client.auth.oauth2.Credential; import com.google.api.client.googleapis.json.GoogleJsonResponseException; import com.google.api.services.samples.youtube.cmdline.Auth; import com.google.api.services.youtube.YouTube; import com.google.api.services.youtube.model.ResourceId; import com.google.api.services.youtube.model.Subscription; import com.google.api.services.youtube.model.SubscriptionSnippet; import com.google.common.collect.Lists; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.List; /** * Subscribe a user to a channel using the YouTube Data API (v3). Use * OAuth 2.0 for authorization. * * @author Ibrahim Ulukaya */ public class AddSubscription { /** * Define a global instance of a Youtube object, which will be used * to make YouTube Data API requests. */ private static YouTube youtube; /** * Subscribe the user's YouTube account to a user-selected channel. * * @param args command line args (not used). */ public static void main(String[] args) { // This OAuth 2.0 access scope allows for full read/write access to the // authenticated user's account. List<String> scopes = Lists.newArrayList("https://www.googleapis.com/auth/youtube"); try { // Authorize the request. Credential credential = Auth.authorize(scopes, "addsubscription"); // This object is used to make YouTube Data API requests. youtube = new YouTube.Builder(Auth.HTTP_TRANSPORT, Auth.JSON_FACTORY, credential).setApplicationName( "youtube-cmdline-addsubscription-sample").build(); // We get the user selected channel to subscribe. // Retrieve the channel ID that the user is subscribing to. String channelId = getChannelId(); System.out.println("You chose " + channelId + " to subscribe."); // Create a resourceId that identifies the channel ID. ResourceId resourceId = new ResourceId(); resourceId.setChannelId(channelId); resourceId.setKind("youtube#channel"); // Create a snippet that contains the resourceId. SubscriptionSnippet snippet = new SubscriptionSnippet(); snippet.setResourceId(resourceId); // Create a request to add the subscription and send the request. // The request identifies subscription metadata to insert as well // as information that the API server should return in its response. Subscription subscription = new Subscription(); subscription.setSnippet(snippet); YouTube.Subscriptions.Insert subscriptionInsert = youtube.subscriptions().insert("snippet,contentDetails", subscription); Subscription returnedSubscription = subscriptionInsert.execute(); // Print information from the API response. System.out.println("\n================== Returned Subscription ==================\n"); System.out.println(" - Id: " + returnedSubscription.getId()); System.out.println(" - Title: " + returnedSubscription.getSnippet().getTitle()); } catch (GoogleJsonResponseException e) { System.err.println("GoogleJsonResponseException code: " + e.getDetails().getCode() + " : " + e.getDetails().getMessage()); e.printStackTrace(); } catch (IOException e) { System.err.println("IOException: " + e.getMessage()); e.printStackTrace(); } catch (Throwable t) { System.err.println("Throwable: " + t.getMessage()); t.printStackTrace(); } } /* * Prompt the user to enter a channel ID and return it. */ private static String getChannelId() throws IOException { String channelId = ""; System.out.print("Please enter a channel id: "); BufferedReader bReader = new BufferedReader(new InputStreamReader(System.in)); channelId = bReader.readLine(); if (channelId.length() < 1) { // If nothing is entered, defaults to "YouTube For Developers." channelId = "UCtVd0c0tGXuTSbU5d8cSBUg"; } return channelId; } }
PHP
O exemplo de código abaixo chama o método subscriptions.insert
da API para adicionar uma assinatura a um canal especificado.
Este exemplo usa a biblioteca cliente PHP.
<?php /** * Library Requirements * * 1. Install composer (https://getcomposer.org) * 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'; session_start(); /* * You can acquire an OAuth 2.0 client ID and client secret from the * Google API Console <https://console.cloud.google.com/> * For more information about using OAuth 2.0 to access Google APIs, please see: * <https://developers.google.com/youtube/v3/guides/authentication> * Please ensure that you have enabled the YouTube Data API for your project. */ $OAUTH2_CLIENT_ID = 'REPLACE_ME'; $OAUTH2_CLIENT_SECRET = 'REPLACE_ME'; $client = new Google_Client(); $client->setClientId($OAUTH2_CLIENT_ID); $client->setClientSecret($OAUTH2_CLIENT_SECRET); $client->setScopes('https://www.googleapis.com/auth/youtube'); $redirect = filter_var('http://' . $_SERVER['HTTP_HOST'] . $_SERVER['PHP_SELF'], FILTER_SANITIZE_URL); $client->setRedirectUri($redirect); // 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.'); } $client->authenticate($_GET['code']); $_SESSION[$tokenSessionKey] = $client->getAccessToken(); header('Location: ' . $redirect); } if (isset($_SESSION[$tokenSessionKey])) { $client->setAccessToken($_SESSION[$tokenSessionKey]); } // Check to ensure that the access token was successfully acquired. if ($client->getAccessToken()) { $htmlBody = ''; try { // This code subscribes the authenticated user to the specified channel. // Identify the resource being subscribed to by specifying its channel ID // and kind. $resourceId = new Google_Service_YouTube_ResourceId(); $resourceId->setChannelId('UCtVd0c0tGXuTSbU5d8cSBUg'); $resourceId->setKind('youtube#channel'); // Create a snippet object and set its resource ID. $subscriptionSnippet = new Google_Service_YouTube_SubscriptionSnippet(); $subscriptionSnippet->setResourceId($resourceId); // Create a subscription request that contains the snippet object. $subscription = new Google_Service_YouTube_Subscription(); $subscription->setSnippet($subscriptionSnippet); // Execute the request and return an object containing information // about the new subscription. $subscriptionResponse = $youtube->subscriptions->insert('id,snippet', $subscription, array()); $htmlBody .= "<h3>Subscription</h3><ul>"; $htmlBody .= sprintf('<li>%s (%s)</li>', $subscriptionResponse['snippet']['title'], $subscriptionResponse['id']); $htmlBody .= '</ul>'; } catch (Google_Service_Exception $e) { $htmlBody .= sprintf('<p>A service error occurred: <code>%s</code></p>', htmlspecialchars($e->getMessage())); } catch (Google_Exception $e) { $htmlBody .= sprintf('<p>An client error occurred: <code>%s</code></p>', htmlspecialchars($e->getMessage())); } $_SESSION[$tokenSessionKey] = $client->getAccessToken(); } elseif ($OAUTH2_CLIENT_ID == 'REPLACE_ME') { $htmlBody = <<<END <h3>Client Credentials Required</h3> <p> You need to set <code>\$OAUTH2_CLIENT_ID</code> and <code>\$OAUTH2_CLIENT_ID</code> before proceeding. <p> END; } else { // If the user has not authorized the application, start the OAuth 2.0 flow. $state = mt_rand(); $client->setState($state); $_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> END; } ?> <!doctype html> <html> <head> <title>Returned Subscription</title> </head> <body> <?=$htmlBody?> </body> </html>
Python
O exemplo de código abaixo chama o método subscriptions.insert
da API para adicionar uma assinatura a um canal especificado.
Este exemplo usa a biblioteca cliente Python.
#!/usr/bin/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 oauth2client.tools 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 # https://console.cloud.google.com/. # 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: # https://developers.google.com/youtube/v3/guides/authentication # For more information about the client_secrets.json file format, see: # https://developers.google.com/api-client-library/python/guide/aaa_client_secrets CLIENT_SECRETS_FILE = "client_secrets.json" # This OAuth 2.0 access scope allows for full read/write access to the # authenticated user's account. YOUTUBE_READ_WRITE_SCOPE = "https://www.googleapis.com/auth/youtube" YOUTUBE_API_SERVICE_NAME = "youtube" YOUTUBE_API_VERSION = "v3" # This variable defines a message to display if the CLIENT_SECRETS_FILE is # missing. MISSING_CLIENT_SECRETS_MESSAGE = """ WARNING: Please configure OAuth 2.0 To make this sample run you will need to populate the client_secrets.json file found at: %s with information from the API Console https://console.cloud.google.com/ For more information about the client_secrets.json file format, please visit: https://developers.google.com/api-client-library/python/guide/aaa_client_secrets """ % os.path.abspath(os.path.join(os.path.dirname(__file__), CLIENT_SECRETS_FILE)) def get_authenticated_service(args): flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE, scope=YOUTUBE_READ_WRITE_SCOPE, message=MISSING_CLIENT_SECRETS_MESSAGE) storage = Storage("%s-oauth2.json" % sys.argv[0]) credentials = storage.get() if credentials is None or credentials.invalid: credentials = run_flow(flow, storage, args) return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, http=credentials.authorize(httplib2.Http())) # This method calls the API's youtube.subscriptions.insert method to add a # subscription to the specified channel. def add_subscription(youtube, channel_id): add_subscription_response = youtube.subscriptions().insert( part='snippet', body=dict( snippet=dict( resourceId=dict( channelId=channel_id ) ) )).execute() return add_subscription_response["snippet"]["title"] if __name__ == "__main__": argparser.add_argument("--channel-id", help="ID of the channel to subscribe to.", default="UCtVd0c0tGXuTSbU5d8cSBUg") args = argparser.parse_args() youtube = get_authenticated_service(args) try: channel_title = add_subscription(youtube, args.channel_id) except HttpError, e: print "An HTTP error %d occurred:\n%s" % (e.resp.status, e.content) else: print "A subscription to '%s' was added." % channel_title
Ruby
O exemplo de código abaixo chama o método subscriptions.insert
da API para adicionar uma assinatura a um canal especificado.
Este exemplo usa a biblioteca 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' # This OAuth 2.0 access scope allows for full read/write access to the # authenticated user's account. YOUTUBE_SCOPE = 'https://www.googleapis.com/auth/youtube' 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_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 :channel_id, 'ID of the channel to subscribe to.', :type => String, :default => 'UCtVd0c0tGXuTSbU5d8cSBUg' end client, youtube = get_authenticated_service begin body = { :snippet => { :resourceId => { :channelId => opts[:channel_id] } } } # Call the API's youtube.subscriptions.insert method to add the subscription # to the specified channel. subscriptions_response = client.execute!( :api_method => youtube.subscriptions.insert, :parameters => { :part => body.keys.join(',') }, :body_object => body ) puts "A subscription to '#{subscriptions_response.data.snippet.title}' was added." rescue Google::APIClient::TransmissionError => e puts e.result.body end end main
Erros
A tabela abaixo identifica as mensagens de erro que a API pode retornar em resposta a uma chamada para este método. Consulte a documentação mensagem de erro para mais detalhes.
Tipo de erro | Detalhe do erro | Descrição |
---|---|---|
badRequest |
accountClosed |
A conta que está tentando criar a inscrição foi fechada. |
badRequest |
accountSuspended |
A conta que está tentando criar a inscrição foi suspensa. |
badRequest |
subscriptionDuplicate |
A inscrição que você está tentando criar já existe. |
forbidden |
subscriptionForbidden |
A solicitação não está devidamente autenticada ou não é suportada para este canal. |
notFound |
publisherNotFound |
O recurso especificado pela propriedade snippet.resourceId da solicitação não pode ser encontrado. |
notFound |
subscriberNotFound |
O assinante identificado com a solicitação não pode ser encontrado. |
required |
publisherRequired |
O recurso de inscrição especificado na solicitação deve usar a propriedade snippet.resourceId para identificar o canal ao qual ele está sendo inscrito. |
Conheça agora.
Use o Explorador de API para chamar este método em dados ativos e ver a solicitação e a resposta da API.