關於 vyond中文 ，我們在網路上蒐集到這些相關的討論、資訊與評價

Para ejecutar las muestras de código de PHP en este documento, necesitarás lo siguiente:

La biblioteca cliente de las APIs de Google para PHP:

 composer require google/apiclient:^2.15.0

Consulta la biblioteca cliente de las APIs de Google para PHP para obtener más información.

Para ejecutar las muestras de código de Python en este documento, necesitarás lo siguiente:

 pip install --upgrade google-api-python-client

 pip install --upgrade google-auth google-auth-oauthlib google-auth-httplib2

 pip install --upgrade flask

 pip install --upgrade requests

Revisa la nota de la versión de la biblioteca cliente de Python de la API de Google si no puedes actualizar Python y la guía de migración asociada.

Para ejecutar las muestras de código de Ruby en este documento, necesitarás lo siguiente:

La biblioteca de Google Auth para Ruby:

 gem install googleauth

El framework de aplicaciones web de Ruby Sinatra.

 gem install sinatra

Para ejecutar las muestras de código de Node.js en este documento, necesitarás lo siguiente:

El cliente de Node.js de las APIs de Google:

npm install googleapis crypto express express-session

No necesitas instalar ninguna biblioteca para poder llamar directamente a los extremos de OAuth 2.0.

En el siguiente fragmento de código, se crea un objeto Google\Client(), que define los parámetros en la solicitud de autorización.

Ese objeto usa información de tu archivo client_secret.json para identificar tu aplicación. (Consulta Cómo crear credenciales de autorización para obtener más información sobre ese archivo). El objeto también identifica los permisos a los que tu aplicación solicita acceso y la URL al extremo de autenticación de tu aplicación, que controlará la respuesta del servidor de OAuth 2.0 de Google. Por último, el código establece los parámetros opcionales access_type y include_granted_scopes.

Por ejemplo, este código solicita acceso sin conexión para administrar la cuenta de YouTube de un usuario:

use Google\Client;$client = new Client();// Required, call the setAuthConfig function to load authorization credentials from
 // client_secret.json file.
 $client->setAuthConfig('client_secret.json');// Required, to set the scope value, call the addScope function
 $client->addScope(GOOGLE_SERVICE_YOUTUBE::YOUTUBE_FORCE_SSL);// Required, call the setRedirectUri function to specify a valid redirect URI for the
 // provided client_id
 $client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');// Recommended, offline access will give you both an access and refresh token so that
 // your app can refresh the access token without user interaction.
 $client->setAccessType('offline');// Recommended, call the setState function. Using a state value can increase your assurance that
 // an incoming connection is the result of an authentication request.
 $client->setState($sample_passthrough_value);// Optional, if your application knows which user is trying to authenticate, it can use this
 // parameter to provide a hint to the Google Authentication Server.
 $client->setLoginHint('hint@example.com');// Optional, call the setPrompt function to set "consent" will prompt the user for consent
 $client->setPrompt('consent');// Optional, call the setIncludeGrantedScopes function with true to enable incremental
 // authorization
 $client->setIncludeGrantedScopes(true);

En el siguiente fragmento de código, se usa el módulo google-auth-oauthlib.flow para crear la solicitud de autorización.

El código crea un objeto Flow, que identifica tu aplicación con información del archivo client_secret.json que descargaste después de crear credenciales de autorización. Ese objeto también identifica los permisos a los que tu aplicación solicita permiso para acceder y la URL al extremo de autenticación de tu aplicación, que controlará la respuesta del servidor de OAuth 2.0 de Google. Por último, el código configura los parámetros opcionales access_type y include_granted_scopes.

Por ejemplo, este código solicita acceso sin conexión para administrar la cuenta de YouTube de un usuario:

import google.oauth2.credentials
 import google_auth_oauthlib.flow# Required, call the from_client_secrets_file method to retrieve the client ID from a
 # client_secret.json file. The client ID (from that file) and access scopes are required. (You can
 # also use the from_client_config method, which passes the client configuration as it originally
 # appeared in a client secrets file but doesn't access the file itself.)
 flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file('client_secret.json',
     scopes=['https://www.googleapis.com/auth/youtube.force-ssl'])# Required, indicate where the API server will redirect the user after the user completes
 # the authorization flow. The redirect URI is required. The value must exactly
 # match one of the authorized redirect URIs for the OAuth 2.0 client, which you
 # configured in the API Console. If this value doesn't match an authorized URI,
 # you will get a 'redirect_uri_mismatch' error.
 flow.redirect_uri = 'https://www.example.com/oauth2callback'# Generate URL for request to Google's OAuth 2.0 server.
 # Use kwargs to set optional request parameters.
 authorization_url, state = flow.authorization_url(
     # Recommended, enable offline access so that you can refresh an access token without
     # re-prompting the user for permission. Recommended for web server apps.
     access_type='offline',
     # Optional, enable incremental authorization. Recommended as a best practice.
     include_granted_scopes='true',
     # Optional, if your application knows which user is trying to authenticate, it can use this
     # parameter to provide a hint to the Google Authentication Server.
     login_hint='hint@example.com',
     # Optional, set prompt to 'consent' will prompt the user for consent
     prompt='consent')

Usa el archivo client_secrets.json que creaste para configurar un objeto cliente en tu aplicación. Cuando configuras un objeto cliente, especificas los permisos a los que tu aplicación necesita acceder, junto con la URL al extremo de autenticación de tu aplicación, que controlará la respuesta del servidor de OAuth 2.0.

Por ejemplo, este código solicita acceso sin conexión para administrar la cuenta de YouTube de un usuario:

require 'googleauth'
 require 'googleauth/web_user_authorizer'
 require 'googleauth/stores/redis_token_store'require 'google/apis/youtube_v3'# Required, call the from_file method to retrieve the client ID from a
 # client_secret.json file.
 client_id = Google::Auth::ClientId.from_file('/path/to/client_secret.json')# Required, scope value 
 scope = 'https://www.googleapis.com/auth/youtube.force-ssl'# Required, Authorizers require a storage instance to manage long term persistence of
 # access and refresh tokens.
 token_store = Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new)# Required, indicate where the API server will redirect the user after the user completes
 # the authorization flow. The redirect URI is required. The value must exactly
 # match one of the authorized redirect URIs for the OAuth 2.0 client, which you
 # configured in the API Console. If this value doesn't match an authorized URI,
 # you will get a 'redirect_uri_mismatch' error.
 callback_uri = '/oauth2callback'# To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI
 # from the client_secret.json file. To get these credentials for your application, visit
 # https://console.cloud.google.com/apis/credentials.
 authorizer = Google::Auth::WebUserAuthorizer.new(client_id, scope,
                                                 token_store, callback_uri)

Tu aplicación usa el objeto cliente para realizar operaciones de OAuth 2.0, como generar URLs de solicitud de autorización y aplicar tokens de acceso a solicitudes HTTP.

En el siguiente fragmento de código, se crea un objeto google.auth.OAuth2, que define los parámetros en la solicitud de autorización.

Ese objeto usa información de tu archivo client_secret.json para identificar tu aplicación. Para solicitarle permisos a un usuario y recuperar un token de acceso, redirecciona al usuario a una página de consentimiento.
Para crear una URL de página de consentimiento, sigue estos pasos:

const {google} = require('googleapis');
 const crypto = require('crypto');
 const express = require('express');
 const session = require('express-session');/**
  * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI
  * from the client_secret.json file. To get these credentials for your application, visit
  * https://console.cloud.google.com/apis/credentials.
  */
 const oauth2Client = new google.auth.OAuth2(
   YOUR_CLIENT_ID,
   YOUR_CLIENT_SECRET,
   YOUR_REDIRECT_URL
 );// Access scopes for YouTube API
 const scopes = [
   'https://www.googleapis.com/auth/youtube.force-ssl'
 ];// Generate a secure random state value.
 const state = crypto.randomBytes(32).toString('hex');// Store state in the session
 req.session.state = state;// Generate a url that asks permissions for the Drive activity and Google Calendar scope
 const authorizationUrl = oauth2Client.generateAuthUrl({
   // 'online' (default) or 'offline' (gets refresh_token)
   access_type: 'offline',
   /** Pass in the scopes array defined above.
     * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
   scope: scopes,
   // Enable incremental authorization. Recommended as a best practice.
   include_granted_scopes: true,
   // Include the state parameter to reduce the risk of CSRF attacks.
   state: state
 });

Nota importante: refresh_token solo se muestra en la primera autorización. Obtén más información
aquí.

El extremo de OAuth 2.0 de Google se encuentra en https://accounts.google.com/o/oauth2/v2/auth. Solo se puede acceder a este extremo a través de HTTPS. Se rechazan las conexiones HTTP simples.

$auth_url = $client->createAuthUrl();

header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));

En este ejemplo, se muestra cómo redireccionar al usuario a la URL de autorización con el framework de aplicaciones web de Flask:

return flask.redirect(authorization_url)

auth_uri = authorizer.get_authorization_url(request: request)

res.redirect(authorizationUrl);

La URL de ejemplo que se muestra a continuación solicita acceso sin conexión (access_type=offline) a un alcance que permite ver la cuenta de YouTube del usuario. Usa la autorización incremental para garantizar que el nuevo token de acceso cubra cualquier permiso al que el usuario haya otorgado acceso a la aplicación anteriormente. La URL también establece valores para los parámetros redirect_uri, response_type y client_id obligatorios, así como para el parámetro state. La URL contiene saltos de línea y espacios para facilitar la lectura.

 https://accounts.google.com/o/oauth2/v2/auth?
  scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.readonly&
  access_type=offline&
  include_granted_scopes=true&
  state=state_parameter_passthrough_value&
  redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback&
  response_type=code&
  client_id=client_id

Después de crear la URL de solicitud, redirecciona al usuario a ella.

Para intercambiar un código de autorización por un token de acceso, usa el método fetchAccessTokenWithAuthCode:

$access_token = $client->fetchAccessTokenWithAuthCode($_GET['code']);

En tu página de devolución de llamada, usa la biblioteca google-auth para verificar la respuesta del servidor de autorización. Luego, usa el método flow.fetch_token para intercambiar el código de autorización de esa respuesta por un token de acceso:

state = flask.session['state']
 flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
     'client_secret.json',
     scopes=['https://www.googleapis.com/auth/youtube.force-ssl'],
     state=state)
 flow.redirect_uri = flask.url_for('oauth2callback', _external=True)authorization_response = flask.request.url
 flow.fetch_token(authorization_response=authorization_response)# Store the credentials in the session.
 # ACTION ITEM for developers:
 #     Store user's access and refresh tokens in your data store if
 #     incorporating this code into your real app.
 credentials = flow.credentials
 flask.session['credentials'] = {
     'token': credentials.token,
     'refresh_token': credentials.refresh_token,
     'token_uri': credentials.token_uri,
     'client_id': credentials.client_id,
     'client_secret': credentials.client_secret,
     'granted_scopes': credentials.granted_scopes}

En tu página de devolución de llamada, usa la biblioteca googleauth para verificar la respuesta del servidor de autorización. Usa el método authorizer.handle_auth_callback_deferred para guardar el código de autorización y redireccionar a la URL que solicitó la autorización originalmente. Esto aplaza el intercambio del código, ya que oculta temporalmente los resultados en la sesión del usuario.

  target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request)
   redirect target_url

Para intercambiar un código de autorización por un token de acceso, usa el método getToken:

const url = require('url');// Receive the callback from Google's OAuth 2.0 server.
 app.get('/oauth2callback', async (req, res) => {
   let q = url.parse(req.url, true).query;  if (q.error) { // An error response e.g. error=access_denied
     console.log('Error:' + q.error);
   } else if (q.state !== req.session.state) { //check state value
     console.log('State mismatch. Possible CSRF attack');
     res.end('State mismatch. Possible CSRF attack');
   } else { // Get access and refresh tokens (if access_type is offline)    let { tokens } = await oauth2Client.getToken(q.code);
     oauth2Client.setCredentials(tokens);
 });

Para intercambiar un código de autorización por un token de acceso, llama al extremo https://oauth2.googleapis.com/token y establece los siguientes parámetros:

En el siguiente fragmento, se muestra una solicitud de muestra:

POST /token HTTP/1.1
 Host: oauth2.googleapis.com
 Content-Type: application/x-www-form-urlencodedcode=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7&
 client_id=your_client_id&
 client_secret=your_client_secret&
 redirect_uri=https%3A//oauth2.example.com/code&
 grant_type=authorization_code

Google responde a esta solicitud mostrando un objeto JSON que contiene un token de acceso de corta duración y un token de actualización. Ten en cuenta que el token de actualización solo se muestra si tu aplicación configuró el parámetro access_type como offline en la solicitud inicial al servidor de autorización de Google.

La respuesta contiene los siguientes campos:

En el siguiente fragmento, se muestra una respuesta de ejemplo:

{
   "access_token": "1/fFAGRNJru1FTz70BzhT3Zg",
   "expires_in": 3920,
   "token_type": "Bearer",
   "scope": "https://www.googleapis.com/auth/youtube.force-ssl",
   "refresh_token": "1//xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI"
 }

Para verificar qué permisos otorgó el usuario, usa el método getGrantedScope():

// Space-separated string of granted scopes if it exists, otherwise null.
 $granted_scopes = $client->getOAuth2Service()->getGrantedScope();

El objeto credentials que se muestra tiene una propiedad granted_scopes, que es una lista de los permisos que el usuario otorgó a tu app.

credentials = flow.credentials
 flask.session['credentials'] = {
     'token': credentials.token,
     'refresh_token': credentials.refresh_token,
     'token_uri': credentials.token_uri,
     'client_id': credentials.client_id,
     'client_secret': credentials.client_secret,
     'granted_scopes': credentials.granted_scopes}

Cuando solicites varios permisos a la vez, verifica qué permisos se otorgaron a través de la propiedad scope del objeto credentials.

# User authorized the request. Now, check which scopes were granted.
 if credentials.scope.include?(Google::Apis::YoutubeV3::AUTH_YOUTUBE_FORCE_SSL)
   # User authorized permission to see, edit, and permanently delete the
   # YouTube videos, ratings, comments and captions.
   # Calling the APIs, etc
 else
   # User didn't authorize the permission.
   # Update UX and application accordingly
 end

Cuando solicites varios permisos a la vez, verifica qué permisos se otorgaron a través de la propiedad scope del objeto tokens.

// User authorized the request. Now, check which scopes were granted.
 if (tokens.scope.includes('https://www.googleapis.com/auth/youtube.force-ssl'))
 {
   // User authorized permission to see, edit, and permanently delete the
   // YouTube videos, ratings, comments and captions.
   // Calling the APIs, etc.
 }
 else
 {
   // User didn't authorize read-only Drive activity permission.
   // Update UX and application accordingly
 }

Para verificar si el usuario otorgó a tu aplicación acceso a un alcance en particular, examina el campo scope en la respuesta del token de acceso. Los permisos de acceso que otorga el access_token expresados como una lista de cadenas separadas por espacios y sensibles a mayúsculas y minúsculas.

Por ejemplo, la siguiente respuesta de muestra del token de acceso indica que el usuario le otorgó permiso a tu aplicación para ver, editar y borrar de forma permanente sus videos, calificaciones, comentarios y subtítulos de YouTube:

  {
     "access_token": "1/fFAGRNJru1FTz70BzhT3Zg",
     "expires_in": 3920,
     "token_type": "Bearer",
     "scope": "https://www.googleapis.com/auth/youtube.force-ssl",
     "refresh_token": "1//xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI"
   }

Para usar el token de acceso y llamar a las APIs de Google, completa los siguientes pasos:

$client->setAccessToken($access_token);

$youtube = new Google_Service_YouTube($client);

$channel = $youtube->channels->listChannels('snippet', array('mine' => $mine));

Después de obtener un token de acceso, tu aplicación puede usarlo para autorizar solicitudes a la API en nombre de una cuenta de usuario o de servicio determinada. Usa las credenciales de autorización específicas del usuario para compilar un objeto de servicio para la API a la que deseas llamar y, luego, usa ese objeto para realizar solicitudes a la API autorizadas.

from googleapiclient.discovery import buildyoutube = build('youtube', 'v3', credentials=credentials)

channel = youtube.channels().list(mine=True, part='snippet').execute()

Después de obtener un token de acceso, tu aplicación puede usarlo para realizar solicitudes a la API en nombre de una cuenta de usuario o de servicio determinada. Usa las credenciales de autorización específicas del usuario para compilar un objeto de servicio para la API a la que deseas llamar y, luego, usa ese objeto para realizar solicitudes a la API autorizadas.

youtube = Google::Apis::YoutubeV3::YouTubeService.new

youtube.authorization = credentials

channel = youtube.list_channels(part, :mine => mine)

Como alternativa, se puede proporcionar la autorización por método si se proporciona el parámetro options a un método:

channel = youtube.list_channels(part, :mine => mine, options: { authorization: auth_client })

Después de obtener un token de acceso y configurarlo en el objeto OAuth2, úsalo para llamar a las APIs de Google. Tu aplicación puede usar ese token para autorizar solicitudes a la API en nombre de una cuenta de usuario o de servicio determinada. Compila un objeto de servicio para la API a la que deseas llamar.
Por ejemplo, el siguiente código usa la API de Google Drive para mostrar una lista de nombres de archivos en el Drive del usuario.

const { google } = require('googleapis');// Example of using YouTube API to list channels.
 var service = google.youtube('v3');
 service.channels.list({
   auth: oauth2Client,
   part: 'snippet,contentDetails,statistics',
   forUsername: 'GoogleDevelopers'
 }, function (err, response) {
   if (err) {
     console.log('The API returned an error: ' + err);
     return;
   }
   var channels = response.data.items;
   if (channels.length == 0) {
     console.log('No channel found.');
   } else {
     console.log('This channel\'s ID is %s. Its title is \'%s\', and ' +
       'it has %s views.',
       channels[0].id,
       channels[0].snippet.title,
       channels[0].statistics.viewCount);
   }
 });

Una vez que tu aplicación obtenga un token de acceso, podrás usarlo para realizar llamadas a una API de Google en nombre de una cuenta de usuario determinada si se otorgaron los permisos de acceso que requiere la API. Para ello, incluye el token de acceso en una solicitud a la API con un parámetro de consulta access_token o un valor Bearer de encabezado HTTP Authorization. Cuando sea posible, se prefiere el encabezado HTTP, ya que las cadenas de consulta suelen ser visibles en los registros del servidor. En la mayoría de los casos, puedes usar una biblioteca cliente para configurar tus llamadas a las APIs de Google (por ejemplo, cuando llamas a la API de YouTube Data).

Ten en cuenta que la API de YouTube Data admite cuentas de servicio solo para propietarios de contenido de YouTube que poseen y administran varios canales de YouTube, como sellos discográficos y estudios cinematográficos.

Puedes probar todas las APIs de Google y ver sus permisos en OAuth 2.0 Playground.

Una llamada al extremo
youtube.channels (la API de datos de YouTube) con el encabezado HTTP Authorization: Bearer podría verse de la siguiente manera. Ten en cuenta que debes especificar tu propio token de acceso:

 GET /youtube/v3/channels?part=snippet&mine=true HTTP/1.1
 Host: www.googleapis.com
 Authorization: Bearer access_token

Esta es una llamada a la misma API para el usuario autenticado con el parámetro de cadena de consulta access_token:

 GET https://www.googleapis.com/youtube/v3/channels?access_token=access_token&part=snippet&mine=true

Puedes probar estos comandos con la aplicación de línea de comandos curl. A continuación, se muestra un ejemplo que usa la opción de encabezado HTTP (preferida):

 curl -H "Authorization: Bearer access_token" https://www.googleapis.com/youtube/v3/channels?part=snippet&mine=true

O bien, la opción de parámetro de cadena de consulta:

 curl https://www.googleapis.com/youtube/v3/channels?access_token=access_token&part=snippet&mine=true

Para ejecutar este ejemplo, haz lo siguiente:

 mkdir ~/php-oauth2-example
 cd ~/php-oauth2-example

 composer require google/apiclient:^2.15.0

 php -S localhost:8080 ~/php-oauth2-example

<?php
 require_once __DIR__.'/vendor/autoload.php';session_start();$client = new Google\Client();
 $client->setAuthConfig('client_secret.json');// User granted permission as an access token is in the session.
 if (isset($_SESSION['access_token']) && $_SESSION['access_token'])
 {
   $client->setAccessToken($_SESSION['access_token']);
   
   $youtube = new Google_Service_YouTube($client);
   $channel = $youtube->channels->listChannels('snippet', array('mine' => $mine));
   echo json_encode($channel);
   
 }
 else
 {
   // Redirect users to outh2call.php which redirects users to Google OAuth 2.0
   $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php';
   header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
 }
 ?>

<?php
 require_once __DIR__.'/vendor/autoload.php';session_start();$client = new Google\Client();// Required, call the setAuthConfig function to load authorization credentials from
 // client_secret.json file.
 $client->setAuthConfigFile('client_secret.json');
 $client->setRedirectUri('http://' . $_SERVER['HTTP_HOST']. $_SERVER['PHP_SELF']);// Required, to set the scope value, call the addScope function.
 $client->addScope(GOOGLE_SERVICE_YOUTUBE::YOUTUBE_FORCE_SSL);// Enable incremental authorization. Recommended as a best practice.
 $client->setIncludeGrantedScopes(true);// Recommended, offline access will give you both an access and refresh token so that
 // your app can refresh the access token without user interaction.
 $client->setAccessType("offline");// Generate a URL for authorization as it doesn't contain code and error
 if (!isset($_GET['code']) && !isset($_GET['error']))
 {
   // Generate and set state value
   $state = bin2hex(random_bytes(16));
   $client->setState($state);
   $_SESSION['state'] = $state;  // Generate a url that asks permissions.
   $auth_url = $client->createAuthUrl();
   header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
 }// User authorized the request and authorization code is returned to exchange access and
 // refresh tokens.
 if (isset($_GET['code']))
 {
   // Check the state value
   if (!isset($_GET['state']) || $_GET['state'] !== $_SESSION['state']) {
     die('State mismatch. Possible CSRF attack.');
   }  // Get access and refresh tokens (if access_type is offline)
   $token = $client->fetchAccessTokenWithAuthCode($_GET['code']);  /** Save access and refresh token to the session variables.
     * ACTION ITEM: In a production app, you likely want to save the
     *              refresh token in a secure persistent storage instead. */
   $_SESSION['access_token'] = $token;
   $_SESSION['refresh_token'] = $client->getRefreshToken();
   
   $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/';
   header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
 }// An error response e.g. error=access_denied
 if (isset($_GET['error']))
 {
   echo "Error: ". $_GET['error'];
 }
 ?>

En este ejemplo, se usa el framework Flask. Ejecuta una aplicación web en http://localhost:8080 que te permite probar el flujo de OAuth 2.0. Si vas a esa URL, deberías ver cinco vínculos:

# -*- coding: utf-8 -*-import os
 import flask
 import requestsimport google.oauth2.credentials
 import google_auth_oauthlib.flow
 import googleapiclient.discovery# This variable specifies the name of a file that contains the OAuth 2.0
 # information for this application, including its client_id and client_secret.
 CLIENT_SECRETS_FILE = "client_secret.json"# The OAuth 2.0 access scope allows for access to the
 # authenticated user's account and requires requests to use an SSL connection.
 SCOPES = ['https://www.googleapis.com/auth/youtube.force-ssl']
 API_SERVICE_NAME = 'youtube'
 API_VERSION = 'v3'app = flask.Flask(__name__)
 # Note: A secret key is included in the sample so that it works.
 # If you use this code in your application, replace this with a truly secret
 # key. See https://flask.palletsprojects.com/quickstart/#sessions.
 app.secret_key = 'REPLACE ME - this value is here as a placeholder.'@app.route('/')
 def index():
   return print_index_table()@app.route('/test')
 def test_api_request():
   if 'credentials' not in flask.session:
   return flask.redirect('authorize')  # Load credentials from the session.
   credentials = google.oauth2.credentials.Credentials(
     **flask.session['credentials'])  youtube = googleapiclient.discovery.build(
     API_SERVICE_NAME, API_VERSION, credentials=credentials)  channel = youtube.channels().list(mine=True, part='snippet').execute()  # Save credentials back to session in case access token was refreshed.
   # ACTION ITEM: In a production app, you likely want to save these
   #              credentials in a persistent database instead.
   flask.session['credentials'] = credentials_to_dict(credentials)  return flask.jsonify(**channel)
 @app.route('/authorize')
 def authorize():
   # Create flow instance to manage the OAuth 2.0 Authorization Grant Flow steps.
   flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
       CLIENT_SECRETS_FILE, scopes=SCOPES)  # The URI created here must exactly match one of the authorized redirect URIs
   # for the OAuth 2.0 client, which you configured in the API Console. If this
   # value doesn't match an authorized URI, you will get a 'redirect_uri_mismatch'
   # error.
   flow.redirect_uri = flask.url_for('oauth2callback', _external=True)  authorization_url, state = flow.authorization_url(
       # Enable offline access so that you can refresh an access token without
       # re-prompting the user for permission. Recommended for web server apps.
       access_type='offline',
       # Enable incremental authorization. Recommended as a best practice.
       include_granted_scopes='true')  # Store the state so the callback can verify the auth server response.
   flask.session['state'] = state  return flask.redirect(authorization_url)@app.route('/oauth2callback')
 def oauth2callback():
   # Specify the state when creating the flow in the callback so that it can
   # verified in the authorization server response.
   state = flask.session['state']  flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
       CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
   flow.redirect_uri = flask.url_for('oauth2callback', _external=True)  # Use the authorization server's response to fetch the OAuth 2.0 tokens.
   authorization_response = flask.request.url
   flow.fetch_token(authorization_response=authorization_response)  # Store credentials in the session.
   # ACTION ITEM: In a production app, you likely want to save these
   #              credentials in a persistent database instead.
   credentials = flow.credentials
   
   flask.session['credentials'] = credentials_to_dict(credentials)  return flask.redirect(flask.url_for('test_api_request'))
   @app.route('/revoke')
 def revoke():
   if 'credentials' not in flask.session:
     return ('You need to <a href="/authorize">authorize</a> before ' +
             'testing the code to revoke credentials.')  credentials = google.oauth2.credentials.Credentials(
     **flask.session['credentials'])  revoke = requests.post('https://oauth2.googleapis.com/revoke',
       params={'token': credentials.token},
       headers = {'content-type': 'application/x-www-form-urlencoded'})  status_code = getattr(revoke, 'status_code')
   if status_code == 200:
     return('Credentials successfully revoked.' + print_index_table())
   else:
     return('An error occurred.' + print_index_table())@app.route('/clear')
 def clear_credentials():
   if 'credentials' in flask.session:
     del flask.session['credentials']
   return ('Credentials have been cleared.<br><br>' +
           print_index_table())def credentials_to_dict(credentials):
   return {'token': credentials.token,
           'refresh_token': credentials.refresh_token,
           'token_uri': credentials.token_uri,
           'client_id': credentials.client_id,
           'client_secret': credentials.client_secret,
           'granted_scopes': credentials.granted_scopes}def print_index_table():
   return ('<table>' +
           '<tr><td><a href="/test">Test an API request</a></td>' +
           '<td>Submit an API request and see a formatted JSON response. ' +
           '    Go through the authorization flow if there are no stored ' +
           '    credentials for the user.</td></tr>' +
           '<tr><td><a href="/authorize">Test the auth flow directly</a></td>' +
           '<td>Go directly to the authorization flow. If there are stored ' +
           '    credentials, you still might not be prompted to reauthorize ' +
           '    the application.</td></tr>' +
           '<tr><td><a href="/revoke">Revoke current credentials</a></td>' +
           '<td>Revoke the access token associated with the current user ' +
           '    session. After revoking credentials, if you go to the test ' +
           '    page, you should see an <code>invalid_grant</code> error.' +
           '</td></tr>' +
           '<tr><td><a href="/clear">Clear Flask session credentials</a></td>' +
           '<td>Clear the access token currently stored in the user session. ' +
           '    After clearing the token, if you <a href="/test">test the ' +
           '    API request</a> again, you should go back to the auth flow.' +
           '</td></tr></table>')if __name__ == '__main__':
   # When running locally, disable OAuthlib's HTTPs verification.
   # ACTION ITEM for developers:
   #     When running in production *do not* leave this option enabled.
   os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'  # This disables the requested scopes and granted scopes check.
   # If users only grant partial request, the warning would not be thrown.
   os.environ['OAUTHLIB_RELAX_TOKEN_SCOPE'] = '1'  # Specify a hostname and port that are set as a valid redirect URI
   # for your API project in the Google API Console.
   app.run('localhost', 8080, debug=True)

En este ejemplo, se usa el framework Sinatra.

require 'googleauth'
 require 'googleauth/web_user_authorizer'
 require 'googleauth/stores/redis_token_store'require 'google/apis/youtube_v3'require 'sinatra'configure do
   enable :sessions  # Required, call the from_file method to retrieve the client ID from a
   # client_secret.json file.
   set :client_id, Google::Auth::ClientId.from_file('/path/to/client_secret.json')  # Required, scope value
   # Access scopes for retrieving data about the user's YouTube channel.
   scope = 'Google::Apis::YoutubeV3::AUTH_YOUTUBE_FORCE_SSL'  # Required, Authorizers require a storage instance to manage long term persistence of
   # access and refresh tokens.
   set :token_store, Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new)  # Required, indicate where the API server will redirect the user after the user completes
   # the authorization flow. The redirect URI is required. The value must exactly
   # match one of the authorized redirect URIs for the OAuth 2.0 client, which you
   # configured in the API Console. If this value doesn't match an authorized URI,
   # you will get a 'redirect_uri_mismatch' error.
   set :callback_uri, '/oauth2callback'  # To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI
   # from the client_secret.json file. To get these credentials for your application, visit
   # https://console.cloud.google.com/apis/credentials.
   set :authorizer, Google::Auth::WebUserAuthorizer.new(settings.client_id, settings.scope,
                           settings.token_store, callback_uri: settings.callback_uri)
 endget '/' do
   # NOTE: Assumes the user is already authenticated to the app
   user_id = request.session['user_id']  # Fetch stored credentials for the user from the given request session.
   # nil if none present
   credentials = settings.authorizer.get_credentials(user_id, request)  if credentials.nil?
     # Generate a url that asks the user to authorize requested scope(s).
     # Then, redirect user to the url.
     redirect settings.authorizer.get_authorization_url(request: request)
   end
   
   # User authorized read-only YouTube Data API permission.
   # Example of using YouTube Data API to list user's YouTube channel
   youtube = Google::Apis::YoutubeV3::YouTubeService.new
   channel = youtube.list_channels(part, :mine => mine, options: { authorization: auth_client })
   
   "<pre>#{JSON.pretty_generate(channel.to_h)}</pre>"
 end# Receive the callback from Google's OAuth 2.0 server.
 get '/oauth2callback' do
   # Handle the result of the oauth callback. Defers the exchange of the code by
   # temporarily stashing the results in the user's session.
   target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request)
   redirect target_url
 end

Para ejecutar este ejemplo, haz lo siguiente:

 mkdir ~/nodejs-oauth2-example
 cd ~/nodejs-oauth2-example

npm install googleapis

node .\main.js

const http = require('http');
 const https = require('https');
 const url = require('url');
 const { google } = require('googleapis');
 const crypto = require('crypto');
 const express = require('express');
 const session = require('express-session');/**
  * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI.
  * To get these credentials for your application, visit
  * https://console.cloud.google.com/apis/credentials.
  */
 const oauth2Client = new google.auth.OAuth2(
   YOUR_CLIENT_ID,
   YOUR_CLIENT_SECRET,
   YOUR_REDIRECT_URL
 );// Access scopes for YouTube API
 const scopes = [
   'https://www.googleapis.com/auth/youtube.force-ssl'
 ];/* Global variable that stores user credential in this code example.
  * ACTION ITEM for developers:
  *   Store user's refresh token in your data store if
  *   incorporating this code into your real app.
  *   For more information on handling refresh tokens,
  *   see https://github.com/googleapis/google-api-nodejs-client#handling-refresh-tokens
  */
 let userCredential = null;async function main() {
   const app = express();  app.use(session({
     secret: 'your_secure_secret_key', // Replace with a strong secret
     resave: false,
     saveUninitialized: false,
   }));  // Example on redirecting user to Google's OAuth 2.0 server.
   app.get('/', async (req, res) => {
     // Generate a secure random state value.
     const state = crypto.randomBytes(32).toString('hex');
     // Store state in the session
     req.session.state = state;    // Generate a url that asks permissions for the Drive activity and Google Calendar scope
     const authorizationUrl = oauth2Client.generateAuthUrl({
       // 'online' (default) or 'offline' (gets refresh_token)
       access_type: 'offline',
       /** Pass in the scopes array defined above.
         * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
       scope: scopes,
       // Enable incremental authorization. Recommended as a best practice.
       include_granted_scopes: true,
       // Include the state parameter to reduce the risk of CSRF attacks.
       state: state
     });    res.redirect(authorizationUrl);
   });  // Receive the callback from Google's OAuth 2.0 server.
   app.get('/oauth2callback', async (req, res) => {
     // Handle the OAuth 2.0 server response
     let q = url.parse(req.url, true).query;    if (q.error) { // An error response e.g. error=access_denied
       console.log('Error:' + q.error);
     } else if (q.state !== req.session.state) { //check state value
       console.log('State mismatch. Possible CSRF attack');
       res.end('State mismatch. Possible CSRF attack');
     } else { // Get access and refresh tokens (if access_type is offline)
       let { tokens } = await oauth2Client.getToken(q.code);
       oauth2Client.setCredentials(tokens);      /** Save credential to the global variable in case access token was refreshed.
         * ACTION ITEM: In a production app, you likely want to save the refresh token
         *              in a secure persistent database instead. */
       userCredential = tokens;
       
       // Example of using YouTube API to list channels.
       var service = google.youtube('v3');
       service.channels.list({
         auth: oauth2Client,
         part: 'snippet,contentDetails,statistics',
         forUsername: 'GoogleDevelopers'
       }, function (err, response) {
         if (err) {
           console.log('The API returned an error: ' + err);
           return;
         }
         var channels = response.data.items;
         if (channels.length == 0) {
           console.log('No channel found.');
         } else {
           console.log('This channel\'s ID is %s. Its title is \'%s\', and ' +
             'it has %s views.',
             channels[0].id,
             channels[0].snippet.title,
             channels[0].statistics.viewCount);
         }
       });
     }
   });  // Example on revoking a token
   app.get('/revoke', async (req, res) => {
     // Build the string for the POST request
     let postData = "token=" + userCredential.access_token;    // Options for POST request to Google's OAuth 2.0 server to revoke a token
     let postOptions = {
       host: 'oauth2.googleapis.com',
       port: '443',
       path: '/revoke',
       method: 'POST',
       headers: {
         'Content-Type': 'application/x-www-form-urlencoded',
         'Content-Length': Buffer.byteLength(postData)
       }
     };    // Set up the request
     const postReq = https.request(postOptions, function (res) {
       res.setEncoding('utf8');
       res.on('data', d => {
         console.log('Response: ' + d);
       });
     });    postReq.on('error', error => {
       console.log(error)
     });    // Post the request with data
     postReq.write(postData);
     postReq.end();
   });
   const server = http.createServer(app);
   server.listen(8080);
 }
 main().catch(console.error);

En este ejemplo de Python, se usa el framework Flask y la biblioteca Requests para demostrar el flujo web de OAuth 2.0. Para este flujo, te recomendamos que uses la biblioteca cliente de la API de Google para Python. (El ejemplo de la pestaña Python usa la biblioteca cliente).

import json
 import flask
 import requestsapp = flask.Flask(__name__)# To get these credentials (CLIENT_ID CLIENT_SECRET) and for your application, visit
 # https://console.cloud.google.com/apis/credentials.
 CLIENT_ID = '123456789.apps.googleusercontent.com'
 CLIENT_SECRET = 'abc123'  # Read from a file or environmental variable in a real app# Access scopes for YouTube API
 SCOPE = 'https://www.googleapis.com/auth/youtube.force-ssl'# Indicate where the API server will redirect the user after the user completes
 # the authorization flow. The redirect URI is required. The value must exactly
 # match one of the authorized redirect URIs for the OAuth 2.0 client, which you
 # configured in the API Console. If this value doesn't match an authorized URI,
 # you will get a 'redirect_uri_mismatch' error.
 REDIRECT_URI = 'http://example.com/oauth2callback'@app.route('/')
 def index():
   if 'credentials' not in flask.session:
     return flask.redirect(flask.url_for('oauth2callback'))  credentials = json.loads(flask.session['credentials'])  if credentials['expires_in'] <= 0:
     return flask.redirect(flask.url_for('oauth2callback'))
   else: 
     headers = {'Authorization': 'Bearer {}'.format(credentials['access_token'])}
     req_uri = 'https://www.googleapis.com/youtube/v3/channels/list'
     r = requests.get(req_uri, headers=headers)
     return r.text @app.route('/oauth2callback')
 def oauth2callback():
   if 'code' not in flask.request.args:
     state = str(uuid.uuid4())
     flask.session['state'] = state
     # Generate a url that asks permissions for the Drive activity
     # and Google Calendar scope. Then, redirect user to the url.
     auth_uri = ('https://accounts.google.com/o/oauth2/v2/auth?response_type=code'
                 '&client_id={}&redirect_uri={}&scope={}&state={}').format(CLIENT_ID, REDIRECT_URI,
                                                                           SCOPE, state)
     return flask.redirect(auth_uri)
   else:
     if 'state' not in flask.request.args or flask.request.args['state'] != flask.session['state']:
       return 'State mismatch. Possible CSRF attack.', 400    auth_code = flask.request.args.get('code')
     data = {'code': auth_code,
             'client_id': CLIENT_ID,
             'client_secret': CLIENT_SECRET,
             'redirect_uri': REDIRECT_URI,
             'grant_type': 'authorization_code'}    # Exchange authorization code for access and refresh tokens (if access_type is offline)
     r = requests.post('https://oauth2.googleapis.com/token', data=data)
     flask.session['credentials'] = r.text
     return flask.redirect(flask.url_for('index'))if __name__ == '__main__':
   import uuid
   app.secret_key = str(uuid.uuid4())
   app.debug = False
   app.run()

$client->setIncludeGrantedScopes(true);

En Python, establece el argumento de palabra clave include_granted_scopes en true para asegurarte de que una solicitud de autorización incluya los permisos otorgados anteriormente. Es muy probable que include_granted_scopes no sea el único argumento de palabra clave que establezcas, como se muestra en el siguiente ejemplo.

authorization_url, state = flow.authorization_url(
     # Enable offline access so that you can refresh an access token without
     # re-prompting the user for permission. Recommended for web server apps.
     access_type='offline',
     # Enable incremental authorization. Recommended as a best practice.
     include_granted_scopes='true')

auth_client.update!(
   :additional_parameters => {"include_granted_scopes" => "true"}
 )

const authorizationUrl = oauth2Client.generateAuthUrl({
   // 'online' (default) or 'offline' (gets refresh_token)
   access_type: 'offline',
   /** Pass in the scopes array defined above.
     * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
   scope: scopes,
   // Enable incremental authorization. Recommended as a best practice.
   include_granted_scopes: true
 });

En este ejemplo, la aplicación que realiza la llamada solicita acceso para recuperar los datos de YouTube Analytics del usuario, además de cualquier otro acceso que el usuario ya haya otorgado a la aplicación.

GET https://accounts.google.com/o/oauth2/v2/auth?
   scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyt-analytics.readonly&
   access_type=offline&
   state=security_token%3D138rk%3Btarget_url%3Dhttp...index&
   redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback&
   response_type=code&
   client_id=client_id&
   include_granted_scopes=true          

If your application needs offline access to a Google API, set the API client's access type to
offline:

$client->setAccessType("offline");

Después de que un usuario otorga acceso sin conexión a los permisos solicitados, puedes seguir usando el cliente de la API para acceder a las APIs de Google en nombre del usuario cuando este no tiene conexión. El objeto cliente actualizará el token de acceso según sea necesario.

En Python, establece el argumento de palabra clave access_type en offline para asegurarte de que puedas actualizar el token de acceso sin tener que volver a solicitarle permiso al usuario. Es muy probable que access_type no sea el único argumento de palabra clave que establezcas, como se muestra en el siguiente ejemplo.

authorization_url, state = flow.authorization_url(
     # Enable offline access so that you can refresh an access token without
     # re-prompting the user for permission. Recommended for web server apps.
     access_type='offline',
     # Enable incremental authorization. Recommended as a best practice.
     include_granted_scopes='true')

Después de que un usuario otorga acceso sin conexión a los permisos solicitados, puedes seguir usando el cliente de la API para acceder a las APIs de Google en nombre del usuario cuando este no tiene conexión. El objeto cliente actualizará el token de acceso según sea necesario.

Si tu aplicación necesita acceso sin conexión a una API de Google, establece el tipo de acceso del cliente de la API en offline:

auth_client.update!(
   :additional_parameters => {"access_type" => "offline"}
 )

Después de que un usuario otorga acceso sin conexión a los permisos solicitados, puedes seguir usando el cliente de la API para acceder a las APIs de Google en nombre del usuario cuando este no tiene conexión. El objeto cliente actualizará el token de acceso según sea necesario.

Si tu aplicación necesita acceso sin conexión a una API de Google, establece el tipo de acceso del cliente de la API en offline:

const authorizationUrl = oauth2Client.generateAuthUrl({
   // 'online' (default) or 'offline' (gets refresh_token)
   access_type: 'offline',
   /** Pass in the scopes array defined above.
     * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
   scope: scopes,
   // Enable incremental authorization. Recommended as a best practice.
   include_granted_scopes: true
 });

Después de que un usuario otorga acceso sin conexión a los permisos solicitados, puedes seguir usando el cliente de la API para acceder a las APIs de Google en nombre del usuario cuando este no tiene conexión. El objeto cliente actualizará el token de acceso según sea necesario.

Los tokens de acceso vencen. Esta biblioteca usará automáticamente un token de actualización para obtener un nuevo token de acceso si está por vencer. Una forma sencilla de asegurarte de almacenar siempre los tokens más recientes
es usar el evento de tokens:

oauth2Client.on('tokens', (tokens) => {
   if (tokens.refresh_token) {
     // store the refresh_token in your secure persistent database
     console.log(tokens.refresh_token);
   }
   console.log(tokens.access_token);
 });

Este evento de tokens solo ocurre en la primera autorización, y debes haber configurado tu access_type como offline cuando llames al método generateAuthUrl para recibir el token de actualización. Si ya le otorgaste a tu app los permisos necesarios sin configurar las restricciones adecuadas para recibir un token de actualización, deberás volver a autorizar la aplicación para que reciba un token de actualización nuevo.

Para configurar el refresh_token más adelante, puedes usar el método setCredentials:

oauth2Client.setCredentials({
   refresh_token: `STORED_REFRESH_TOKEN`
 });

Una vez que el cliente tenga un token de actualización, los tokens de acceso se adquirirán y actualizarán automáticamente en la próxima llamada a la API.

Para actualizar un token de acceso, tu aplicación envía una solicitud POST HTTPS al servidor de autorización de Google (https://oauth2.googleapis.com/token) que incluye los siguientes parámetros:


Campos




client_id
El ID de cliente obtenido de API Console.


client_secret
El secreto de cliente obtenido de API Console




grant_type
Como se define en la especificación de OAuth 2.0, el valor de este campo debe establecerse en refresh_token.


refresh_token
El token de actualización que se muestra después del intercambio de códigos de autorización.

En el siguiente fragmento, se muestra una solicitud de muestra:

 POST /token HTTP/1.1
 Host: oauth2.googleapis.com
 Content-Type: application/x-www-form-urlencodedclient_id=your_client_id&
 client_secret=your_client_secret&
 refresh_token=refresh_token&
 grant_type=refresh_token

Siempre que el usuario no haya revocado el acceso otorgado a la aplicación, el servidor de tokens muestra un objeto JSON que contiene un token de acceso nuevo. En el siguiente fragmento, se muestra una respuesta de ejemplo:

{
   "access_token": "1/fFAGRNJru1FTz70BzhT3Zg",
   "expires_in": 3920,
   "scope": "https://www.googleapis.com/auth/drive.metadata.readonly",
   "token_type": "Bearer"
 }

Ten en cuenta que hay límites en la cantidad de tokens de actualización que se emitirán: un límite por combinación de cliente/usuario y otro por usuario en todos los clientes. Debes guardar los tokens de actualización
en el almacenamiento a largo plazo y seguir usándolos mientras sigan siendo válidos. Si tu aplicación solicita demasiados tokens de actualización, es posible que se encuentre con estos límites, en cuyo caso los tokens de actualización más antiguos dejarán de funcionar.

Para revocar un token de manera programática, llama a revokeToken():

$client->revokeToken();

Para revocar un token de forma programática, realiza una solicitud a
https://oauth2.googleapis.com/revoke que incluya el token como parámetro y establezca el
encabezado Content-Type:

requests.post('https://oauth2.googleapis.com/revoke',
     params={'token': credentials.token},
     headers = {'content-type': 'application/x-www-form-urlencoded'})

Para revocar un token de forma programática, realiza una solicitud HTTP al extremo oauth2.revoke:

uri = URI('https://oauth2.googleapis.com/revoke')
 response = Net::HTTP.post_form(uri, 'token' => auth_client.access_token)

El token puede ser un token de acceso o un token de actualización. Si el token es un token de acceso y tiene un token de actualización correspondiente, este también se revocará.

Si la revocación se procesa correctamente, el código de estado de la respuesta es 200. En el caso de las condiciones de error, se muestra un código de estado 400 junto con un código de error.

Para revocar un token de forma programática, realiza una solicitud HTTPS POST al extremo /revoke:

const https = require('https');// Build the string for the POST request
 let postData = "token=" + userCredential.access_token;// Options for POST request to Google's OAuth 2.0 server to revoke a token
 let postOptions = {
   host: 'oauth2.googleapis.com',
   port: '443',
   path: '/revoke',
   method: 'POST',
   headers: {
     'Content-Type': 'application/x-www-form-urlencoded',
     'Content-Length': Buffer.byteLength(postData)
   }
 };// Set up the request
 const postReq = https.request(postOptions, function (res) {
   res.setEncoding('utf8');
   res.on('data', d => {
     console.log('Response: ' + d);
   });
 });postReq.on('error', error => {
   console.log(error)
 });// Post the request with data
 postReq.write(postData);
 postReq.end();

El parámetro de token puede ser un token de acceso o un token de actualización. Si el token es un token de acceso y tiene un token de actualización correspondiente, este también se revocará.

Si la revocación se procesa correctamente, el código de estado de la respuesta es 200. En el caso de las condiciones de error, se muestra un código de estado 400 junto con un código de error.

Para revocar un token de manera programática, tu aplicación envía una solicitud a https://oauth2.googleapis.com/revoke y, además, incluye el token como parámetro:

 curl -d -X -POST --header "Content-type:application/x-www-form-urlencoded" \
         https://oauth2.googleapis.com/revoke?token={token}

El token puede ser un token de acceso o un token de actualización. Si el token es un token de acceso y tiene un token de actualización correspondiente, este también se revocará.

Si la revocación se procesa correctamente, el código de estado HTTP de la respuesta es 200. Para las condiciones de error, se muestra un código de estado HTTP 400 junto con un código de error.