Como usar o OAuth 2.0 para aplicativos de servidor da Web

PHP

Para executar os exemplos de código PHP neste documento, você precisará de:

• PHP 5.6 ou mais recente com a interface de linha de comando (CLI) e a extensão JSON instaladas.
• A ferramenta de gerenciamento de dependências Composer.

• Biblioteca de cliente de APIs do Google para PHP:

  composer require google/apiclient:^2.10

Python

Para executar os exemplos de código Python neste documento, você precisará de:

• Python 2.6 ou superior
• a ferramenta de gerenciamento de pacotes pip;
• Biblioteca de cliente de APIs do Google para Python:

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

• O google-auth, google-auth-oauthlib e google-auth-httplib2 para autorização do usuário.

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

• O framework de aplicativo da Web Flask Python.

  pip install --upgrade flask

• A biblioteca HTTP requests.

  pip install --upgrade requests

Ruby

Para executar os exemplos de código do Ruby neste documento, você precisará de:

• Ruby 2.6 ou superior

• A biblioteca do Google Auth para Ruby:

  gem install googleauth

• O framework de aplicativo da Web Sinatra Ruby.

  gem install sinatra

Node.js

Para executar os exemplos de código Node.js neste documento, você precisará de:

• O LTS de manutenção, o LTS ativo ou a versão atual do Node.js.

• O cliente Node.js das APIs do Google:

  npm install googleapis crypto express express-session

HTTP/REST

Não é necessário instalar nenhuma biblioteca para chamar diretamente os endpoints do OAuth 2.0.

PHP

O snippet de código abaixo cria um objeto Google\Client(), que define os parâmetros na solicitação de autorização.

Esse objeto usa as informações do seu arquivo client_secret.json para identificar seu aplicativo. Consulte Como criar credenciais de autorização para saber mais sobre esse arquivo. O objeto também identifica os escopos que seu aplicativo está solicitando permissão para acessar e o URL para o endpoint de autenticação do aplicativo, que manipulará a resposta do servidor OAuth 2.0 do Google. Por fim, o código define os parâmetros opcionais access_type e include_granted_scopes.

Por exemplo, para solicitar acesso off-line para recuperar dados do YouTube de um usuário:

$client = new Google\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);

Python

O snippet de código a seguir usa o módulo google-auth-oauthlib.flow para criar a solicitação de autorização.

O código cria um objeto Flow, que identifica seu aplicativo usando informações do arquivo client_secret.json que você salvou depois de criar credenciais de autorização. Esse objeto também identifica os escopos que seu aplicativo está solicitando permissão para acessar e o URL para o endpoint de autenticação do aplicativo, que manipulará a resposta do servidor OAuth 2.0 do Google. Por fim, o código define os parâmetros opcionais access_type e include_granted_scopes.

Por exemplo, para solicitar acesso off-line para recuperar dados do YouTube de um usuário:

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')

Ruby

Use o arquivo client_secrets.json que você criou para configurar um objeto cliente em seu aplicativo. Ao configurar um objeto cliente, você especifica os escopos que seu aplicativo precisa acessar, junto com o URL para o endpoint de autenticação do aplicativo, que lidará com a resposta do servidor OAuth 2.0.

Por exemplo, para solicitar acesso off-line para recuperar dados do YouTube de um usuário:

require 'google/apis/youtube_v3'
require "googleauth"
require 'googleauth/stores/redis_token_store'

client_id = Google::Auth::ClientId.from_file('/path/to/client_secret.json')
scope = 'https://www.googleapis.com/auth/youtube.force-ssl'
token_store = Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new)
authorizer = Google::Auth::WebUserAuthorizer.new(client_id, scope, token_store, '/oauth2callback')

O aplicativo usa o objeto cliente para executar operações do OAuth 2.0, como gerar URLs de solicitação de autorização e aplicar tokens de acesso a solicitações HTTP.

Node.js

O snippet de código a seguir cria um objeto google.auth.OAuth2, que define os parâmetros na solicitação de autorização.

Esse objeto usa as informações de seu arquivo client_secret.json para identificar seu aplicativo. Para solicitar permissões de um usuário para recuperar um token de acesso, redirecione-o para uma página de consentimento. Para criar um URL da página de consentimento:

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 read-only Drive activity.
const scopes = [
  'https://www.googleapis.com/auth/drive.metadata.readonly'
];

// 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 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
});

Observação importante: o refresh_token só é retornado na primeira autorização. Mais detalhes aqui.

HTTP/REST

O endpoint OAuth 2.0 do Google está em https://accounts.google.com/o/oauth2/v2/auth. Esse endpoint só pode ser acessado por HTTPS. Conexões HTTP simples são recusadas.

PHP

1. Gere um URL para solicitar acesso ao servidor OAuth 2.0 do Google:

   $auth_url = $client->createAuthUrl();

2. Redirecionar o usuário para $auth_url:

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

Python

Este exemplo mostra como redirecionar o usuário para o URL de autorização com o framework de aplicativo da Web Flask:

return flask.redirect(authorization_url)

Ruby

1. Gere um URL para solicitar acesso ao servidor OAuth 2.0 do Google:

   auth_uri = authorizer.get_authorization_url(login_hint: user_id, request: request)

2. Redirecione o usuário para auth_uri.

Node.js

1. Use o URL gerado authorizationUrl do método generateAuthUrl da Etapa 1 para solicitar acesso ao servidor OAuth 2.0 do Google.
2. Redirecione o usuário para authorizationUrl.

   res.redirect(authorizationUrl);

HTTP/REST

Sample redirect to Google's authorization server

An example URL is shown below, with line breaks and spaces for readability. The URL requests access to a scope that permits access to retrieve the user's YouTube data. It uses incremental authorization (include_granted_scopes=true) to ensure that the new access token covers any scopes to which the user previously granted the application access. Several other parameters are also set in the example.

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

Depois de criar o URL da solicitação, redirecione o usuário para ele.

PHP

Para trocar um código de autorização por um token de acesso, use o método authenticate:

$client->authenticate($_GET['code']);

Recupere o token de acesso com o método getAccessToken:

$access_token = $client->getAccessToken();

Python

Na página de callback, use a biblioteca google-auth para verificar a resposta do servidor de autorização. Em seguida, use o método flow.fetch_token para trocar o código de autorização dessa resposta por um token de acesso:

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,
    'scopes': credentials.scopes}

Ruby

Na página de callback, use a biblioteca googleauth para verificar a resposta do servidor de autorização. Use o método authorizer.handle_auth_callback_deferred para salvar o código de autorização e redirecionar para o URL que solicitou a autorização originalmente. Isso adia a troca do código, ocultando temporariamente os resultados na sessão do usuário.

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

Node.js

Para trocar um código de autorização por um token de acesso, use o 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);
});

HTTP/REST

Para trocar um código de autorização por um token de acesso, chame o endpoint https://oauth2.googleapis.com/token e defina os seguintes parâmetros:

O snippet a seguir mostra um exemplo de solicitação:

POST /token HTTP/1.1
Host: oauth2.googleapis.com
Content-Type: application/x-www-form-urlencoded

code=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

O Google responde a essa solicitação retornando um objeto JSON que contém um token de acesso de curta duração e um token de atualização. O token de atualização só será retornado se o aplicativo definir o parâmetro access_type como offline na solicitação inicial ao servidor de autorização do Google.

A resposta contém os seguintes campos:

O snippet a seguir mostra um exemplo de resposta:

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

PHP

Use o token de acesso para chamar as APIs do Google seguindo estas etapas:

1. Se você precisar aplicar um token de acesso a um novo objeto Google\Client (por exemplo, se você armazenou o token de acesso em uma sessão de usuário), use o método setAccessToken:

   $client->setAccessToken($access_token);

2. Crie um objeto de serviço para a API que você quer chamar. Crie um objeto de serviço fornecendo um objeto Google\Client autorizado ao construtor da API que você quer chamar. Por exemplo, para chamar a API YouTube Data:

   $youtube = new Google_Service_YouTube($client);

3. Faça solicitações ao serviço da API usando a interface fornecida pelo objeto de serviço. Por exemplo, para usar a API YouTube Data para recuperar uma lista de transmissões ao vivo para o canal do usuário autenticado:

   $broadcasts = $youtube->liveBroadcasts->listLiveBroadcasts('id,snippet', [ 'mine' => true ]);

Python

Depois de receber um token de acesso, seu aplicativo pode usá-lo para autorizar solicitações de API em nome de uma determinada conta de usuário ou de serviço. Use as credenciais de autorização específicas do usuário para criar um objeto de serviço para a API que você quer chamar e, em seguida, use esse objeto para fazer solicitações de API autorizadas.

1. Crie um objeto de serviço para a API que você quer chamar. Para criar um objeto de serviço, chame o método build da biblioteca googleapiclient.discovery com o nome, a versão da API e as credenciais do usuário: Por exemplo, para chamar a versão 3 da API YouTube Data:

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

2. Faça solicitações ao serviço da API usando a interface fornecida pelo objeto de serviço. Por exemplo, para usar a API YouTube Data para recuperar uma lista de transmissões ao vivo para o canal do usuário autenticado:

   broadcasts = youtube.liveBroadcasts().list(part='id,snippet', mine=True).execute()

Ruby

Depois de receber um token de acesso, seu aplicativo pode usá-lo para fazer solicitações de API em nome de uma determinada conta de usuário ou de serviço. Use as credenciais de autorização específicas do usuário para criar um objeto de serviço para a API que você quer chamar e, em seguida, use esse objeto para fazer solicitações de API autorizadas.

1. Crie um objeto de serviço para a API que você quer chamar. Por exemplo, para chamar a versão 3 da API YouTube Data:

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

2. Defina as credenciais no serviço:

   youtube.authorization = credentials

3. Faça solicitações ao serviço da API usando a interface fornecida pelo objeto de serviço. Por exemplo, use a API YouTube Data para recuperar uma lista de transmissões ao vivo do canal do usuário autenticado:

   broadcasts = youtube.list_liveBroadcasts('id,snippet', mine: true)

Como alternativa, a autorização pode ser concedida para cada método, fornecendo o parâmetro options a um método:

broadcasts = youtube.list_liveBroadcasts('id,snippet', mine: true)

Node.js

Depois de receber um token de acesso e defini-lo como o objeto OAuth2, use o objeto para chamar as APIs do Google. Seu aplicativo pode usar esse token para autorizar solicitações de API em nome de uma determinada conta de usuário ou de serviço. Crie um objeto de serviço para a API que você quer chamar.

const { google } = require('googleapis');

// Example of using Google Drive API to list filenames in user's Drive.
const drive = google.drive('v3');
drive.files.list({
  auth: oauth2Client,
  pageSize: 10,
  fields: 'nextPageToken, files(id, name)',
}, (err1, res1) => {
  if (err1) return console.log('The API returned an error: ' + err1);
  const files = res1.data.files;
  if (files.length) {
    console.log('Files:');
    files.map((file) => {
      console.log(`${file.name} (${file.id})`);
    });
  } else {
    console.log('No files found.');
  }
});

HTTP/REST

Depois que o aplicativo recebe um token de acesso, é possível usá-lo para fazer chamadas a uma API do Google em nome de uma determinada conta de usuário se os escopos de acesso exigidos pela API tiverem sido concedidos. Para fazer isso, inclua o token de acesso em uma solicitação à API incluindo um parâmetro de consulta access_token ou um valor Bearer de cabeçalho HTTP Authorization. Recomendamos usar o cabeçalho HTTP sempre que possível, porque as strings de consulta costumam ficar visíveis nos registros do servidor. Na maioria dos casos, você pode usar uma biblioteca de cliente para configurar chamadas para as APIs do Google (por exemplo, ao chamar a API de transmissão do YouTube ao vivo).

A API de transmissão do YouTube ao vivo não é compatível com o fluxo da conta de serviço. Como não há uma forma de vincular uma conta de serviço a uma conta do YouTube, as tentativas de autorizar solicitações com esse fluxo gerarão um erro NoLinkedYouTubeAccount.

É possível testar todas as APIs do Google e ver os escopos delas no OAuth 2.0 Playground.

Exemplos GET HTTP

Uma chamada para o endpoint liveBroadcasts.list (a API YouTube Live Streaming) usando o cabeçalho HTTP Authorization: Bearer pode ter a seguinte aparência: É necessário especificar seu próprio token de acesso:

GET /youtube/v3/liveBroadcasts?part=id%2Csnippet&mine=true HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer access_token

Veja abaixo uma chamada para a mesma API para o usuário autenticado com o parâmetro de string de consulta access_token:

GET https://www.googleapis.com/youtube/v3/liveBroadcasts?access_token=access_token&part=id%2Csnippet&mine=true

Exemplos com curl

É possível testar esses comandos com o aplicativo de linha de comando curl. Veja um exemplo que usa a opção de cabeçalho HTTP (preferencial):

curl -H "Authorization: Bearer access_token" https://www.googleapis.com/youtube/v3/liveBroadcasts?part=id%2Csnippet&mine=true

Ou, alternativamente, a opção do parâmetro da string de consulta:

curl https://www.googleapis.com/youtube/v3/liveBroadcasts?access_token=access_token&part=id%2Csnippet&mine=true

PHP

Para executar esse exemplo:

1. No API Console, adicione o URL da máquina local à lista de URLs de redirecionamento. Por exemplo, adicione http://localhost:8080.
2. Crie um novo diretório e mude para ele. Por exemplo:

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

3. Instale a biblioteca de cliente das APIs do Google para PHP usando o Composer:

   composer require google/apiclient:^2.10

4. Crie os arquivos index.php e oauth2callback.php com o conteúdo abaixo.
5. Execute o exemplo com um servidor da Web configurado para exibir PHP. Se você usar PHP 5.6 ou mais recente, poderá usar o servidor da Web de teste integrado do PHP:

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

index.php

<?php
require_once __DIR__.'/vendor/autoload.php';

session_start();

$client = new Google\Client();
$client->setAuthConfig('client_secrets.json');
$client->addScope(Google_Service_YouTube::YOUTUBE_FORCE_SSL);

if (isset($_SESSION['access_token']) && $_SESSION['access_token']) {
  $client->setAccessToken($_SESSION['access_token']);
  $youtube = new Google_Service_YouTube($client);
  $broadcasts = $youtube->liveBroadcasts->listLiveBroadcasts('id,snippet', [ 'mine' => true ]);
  echo json_encode($broadcasts);
} else {
  $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php';
  header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
}

oauth2callback.php

<?php
require_once __DIR__.'/vendor/autoload.php';

session_start();

$client = new Google\Client();
$client->setAuthConfigFile('client_secrets.json');
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');
$client->addScope(Google_Service_YouTube::YOUTUBE_FORCE_SSL);

if (! isset($_GET['code'])) {
  // Generate and set state value
  $state = bin2hex(random_bytes(16));
  $client->setState($state);
  $_SESSION['state'] = $state;

  $auth_url = $client->createAuthUrl();
  header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
} else {
  // Check the state value
  if (!isset($_GET['state']) || $_GET['state'] !== $_SESSION['state']) {
    die('State mismatch. Possible CSRF attack.');
  }
  $client->authenticate($_GET['code']);
  $_SESSION['access_token'] = $client->getAccessToken();
  $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/';
  header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
}

Python

Neste exemplo, usamos o framework Flask. Ele executa um aplicativo da Web em http://localhost:8080 que permite testar o fluxo do OAuth 2.0. Se você acessar esse URL, verá quatro links:

• Testar uma solicitação de API:esse link aponta para uma página que tenta executar um exemplo de solicitação de API. Se necessário, ele inicia o fluxo de autorização. Se bem-sucedido, a página exibirá a resposta da API.
• Testar o fluxo de autenticação diretamente: esse link aponta para uma página que tenta encaminhar o usuário pelo fluxo de autorização. O app solicita permissão para enviar solicitações de API autorizadas em nome do usuário.
• Revogar credenciais atuais:esse link aponta para uma página que revoga as permissões concedidas pelo usuário ao aplicativo.
• Limpar credenciais da sessão do Flask:esse link limpa as credenciais de autorização que estão armazenadas na sessão do Flask. Isso permite ver o que aconteceria se um usuário que já tinha concedido permissão ao seu app tentasse executar uma solicitação de API em uma nova sessão. Ele também permite que você veja a resposta da API que seu app receberia se um usuário tivesse revogado as permissões concedidas ao app e o app ainda tentasse autorizar uma solicitação com um token de acesso revogado.

# -*- coding: utf-8 -*-

import os
import flask
import requests

import 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"

# This OAuth 2.0 access scope allows for full read/write 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)

  broadcasts = youtube.liveBroadcasts().list(part='id,snippet', mine=True).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(**broadcasts)


@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,
          'scopes': credentials.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'

  # 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)

Ruby

Neste exemplo, usamos o framework Sinatra (em inglês).

require 'google/apis/youtube_v3'
require 'sinatra'
require 'googleauth'
require 'googleauth/stores/redis_token_store'

configure do
  enable :sessions

  set :client_id, Google::Auth::ClientId.from_file('/path/to/client_secret.json')
  set :scope, Google::Apis::DriveV3::AUTH_DRIVE_METADATA_READONLY
  set :token_store, Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new)
  set :authorizer, Google::Auth::WebUserAuthorizer.new(settings.client_id, settings.scope, settings.token_store, '/oauth2callback')
end

get '/' do
  user_id = settings.client_id.id
  credentials = settings.authorizer.get_credentials(user_id, request)
  if credentials.nil?
    redirect settings.authorizer.get_authorization_url(login_hint: user_id, request: request)
  end
  youtube = Google::Apis::YoutubeV3::YouTubeService.new
  broadcasts = youtube.list_liveBroadcasts('id,snippet', mine: true)
  
  "<pre>#{JSON.pretty_generate(broadcasts.to_h)}</pre>"
end

get '/oauth2callback' do
  target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request)
  redirect target_url
end

Node.js

Para executar esse exemplo:

1. No API Console, adicione o URL da máquina local à lista de URLs de redirecionamento. Por exemplo, adicione http://localhost.
2. Verifique se você tem o LTS de manutenção, o LTS ativo ou a versão atual do Node.js instalada.
3. Crie um novo diretório e mude para ele. Por exemplo:

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

4. Install the Google API Client Library for Node.js using npm:

   npm install googleapis

5. Crie os arquivos main.js com o conteúdo abaixo.
6. Execute o exemplo:

   node .\main.js

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 read-only Drive activity.
const scopes = [
  'https://www.googleapis.com/auth/drive.metadata.readonly'
];
/* 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 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 Google Drive API to list filenames in user's Drive.
      const drive = google.drive('v3');
      drive.files.list({
        auth: oauth2Client,
        pageSize: 10,
        fields: 'nextPageToken, files(id, name)',
      }, (err1, res1) => {
        if (err1) return console.log('The API returned an error: ' + err1);
        const files = res1.data.files;
        if (files.length) {
          console.log('Files:');
          files.map((file) => {
            console.log(`${file.name} (${file.id})`);
          });
        } else {
          console.log('No files found.');
        }
      });
    }
  });

  // 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(80);
}
main().catch(console.error);

HTTP/REST

Este exemplo em Python usa o framework Flask e a biblioteca Requests para demonstrar o fluxo da Web do OAuth 2.0. Recomendamos o uso da biblioteca de cliente das APIs do Google para Python nesse fluxo. O exemplo na guia Python usa a biblioteca de cliente.

import json

import flask
import requests


app = flask.Flask(__name__)

CLIENT_ID = '123456789.apps.googleusercontent.com'
CLIENT_SECRET = 'abc123'  # Read from a file or environmental variable in a real app
SCOPE = 'https://www.googleapis.com/auth/youtube.force-ssl'
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://youtube.googleapis.com/youtube/v3/liveBroadcasts'
    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
    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'}
    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()

PHP

$client->setIncludeGrantedScopes(true);

Python

No Python, defina o argumento de palavra-chave include_granted_scopes como true para garantir que uma solicitação de autorização inclua escopos concedidos anteriormente. É muito possível que include_granted_scopes não seja o único argumento de palavra-chave definido, como mostrado no exemplo abaixo.

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')

Ruby

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

Node.js

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
});

HTTP/REST

Neste exemplo, o aplicativo de chamada solicita acesso para recuperar os dados do YouTube do usuário, além de qualquer outro acesso que ele já tenha concedido ao aplicativo.

GET https://accounts.google.com/o/oauth2/v2/auth?
  scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.force-ssl&
  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

      

PHP

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

$client->setAccessType("offline");

Depois que um usuário conceder acesso off-line aos escopos solicitados, será possível continuar utilizando o cliente de API para acessar as APIs do Google em nome do usuário quando ele estiver off-line. O objeto cliente atualizará o token de acesso conforme necessário.

Python

Em Python, defina o argumento de palavra-chave access_type como offline para garantir que será possível atualizar o token de acesso sem precisar solicitar a permissão do usuário novamente. É muito possível que access_type não seja o único argumento de palavra-chave definido, como mostrado no exemplo abaixo.

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')

Depois que um usuário conceder acesso off-line aos escopos solicitados, será possível continuar utilizando o cliente de API para acessar as APIs do Google em nome do usuário quando ele estiver off-line. O objeto cliente atualizará o token de acesso conforme necessário.

Ruby

Caso seu aplicativo precise de acesso off-line a uma API do Google, defina o tipo de acesso do cliente da API como offline:

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

Depois que um usuário conceder acesso off-line aos escopos solicitados, será possível continuar utilizando o cliente de API para acessar as APIs do Google em nome do usuário quando ele estiver off-line. O objeto cliente atualizará o token de acesso conforme necessário.

Node.js

Caso seu aplicativo precise de acesso off-line a uma API do Google, defina o tipo de acesso do cliente da API como 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
});

Depois que um usuário conceder acesso off-line aos escopos solicitados, será possível continuar utilizando o cliente de API para acessar as APIs do Google em nome do usuário quando ele estiver off-line. O objeto cliente atualizará o token de acesso conforme necessário.

Os tokens de acesso expiram. A biblioteca vai usar automaticamente um token de atualização para receber um novo token de acesso se estiver prestes a expirar. Uma maneira fácil de garantir que você sempre armazene os tokens mais recentes é usar o evento 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);
});

Esse evento de tokens ocorre apenas na primeira autorização, e é necessário definir access_type como offline ao chamar o método generateAuthUrl para receber o token de atualização. Se você já concedeu as permissões necessárias ao aplicativo sem definir as restrições apropriadas para o recebimento de um token de atualização, será necessário autorizar novamente o aplicativo a receber um novo token.

Para definir o refresh_token mais tarde, use o método setCredentials:

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

Quando o cliente tiver um token de atualização, os tokens de acesso serão adquiridos e atualizados automaticamente na próxima chamada à API.

HTTP/REST

Para atualizar um token de acesso, o aplicativo envia uma solicitação HTTPS POST ao servidor de autorização do Google (https://oauth2.googleapis.com/token) que inclui os seguintes parâmetros:

O snippet a seguir mostra um exemplo de solicitação:

POST /token HTTP/1.1
Host: oauth2.googleapis.com
Content-Type: application/x-www-form-urlencoded

client_id=your_client_id&
client_secret=your_client_secret&
refresh_token=refresh_token&
grant_type=refresh_token

Contanto que o usuário não tenha revogado o acesso concedido ao aplicativo, o servidor de token retornará um objeto JSON que contém um novo token de acesso. O snippet a seguir mostra um exemplo de resposta:

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

Há limites para o número de tokens de atualização que serão emitidos: um limite por combinação de cliente/usuário e outro por usuário em todos os clientes. Salve esses tokens em um armazenamento de longo prazo e continue a usá-los enquanto permanecerem válidos. Se o aplicativo solicitar muitos tokens de atualização, ele poderá atingir esses limites. Nesse caso, os tokens de atualização mais antigos deixarão de funcionar.

PHP

Para revogar um token de maneira programática, chame revokeToken():

$client->revokeToken();

Python

Para revogar um token de maneira programática, faça uma solicitação para https://oauth2.googleapis.com/revoke que inclua o token como um parâmetro e defina o cabeçalho Content-Type:

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

Ruby

Para revogar um token de maneira programática, faça uma solicitação HTTP para o endpoint oauth2.revoke:

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

O token pode ser um token de acesso ou de atualização. Se for um token de acesso e tiver um token de atualização correspondente, este também será revogado.

Se a revogação for processada com sucesso, o código de status da resposta será 200. Para condições de erro, um código de status 400 é retornado com um código de erro.

Node.js

Para revogar um token de maneira programática, faça uma solicitação POST HTTPS para o endpoint /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();

O parâmetro do token pode ser um token de acesso ou de atualização. Se for um token de acesso e tiver um token de atualização correspondente, este também será revogado.

Se a revogação for processada com sucesso, o código de status da resposta será 200. Para condições de erro, um código de status 400 é retornado com um código de erro.

HTTP/REST

Para revogar um token de forma programática, o aplicativo faz uma solicitação para https://oauth2.googleapis.com/revoke e inclui o token como um parâmetro:

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

O token pode ser um token de acesso ou de atualização. Se for um token de acesso e tiver um token de atualização correspondente, este também será revogado.

Se a revogação for processada com sucesso, o código de status HTTP da resposta será 200. Para condições de erro, um código de status HTTP 400 é retornado com um código de erro.