關於 サイド 英語 ，我們在網路上蒐集到這些相關的討論、資訊與評價

このドキュメントの PHP コードサンプルを実行するには、次のものが必要です。

PHP 用 Google API クライアント ライブラリ:

 composer require google/apiclient:^2.15.0

詳細については、PHP 用 Google API クライアント ライブラリをご覧ください。

このドキュメントの Python コードサンプルを実行するには、次のものが必要です。

 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

Python をアップグレードできない場合は、Google API Python クライアント ライブラリのリリースノートと関連する移行ガイドをご覧ください。

このドキュメントの Ruby コードサンプルを実行するには、次のものが必要です。

Ruby 用 Google 認証ライブラリ:

 gem install googleauth

Sinatra Ruby ウェブ アプリケーション フレームワーク。

 gem install sinatra

このドキュメントの Node.js コードサンプルを実行するには、次のものが必要です。

Google API Node.js クライアント:

npm install googleapis crypto express express-session

OAuth 2.0 エンドポイントを直接呼び出すためにライブラリをインストールする必要はありません。

次のコード スニペットは、認可リクエストのパラメータを定義する Google\Client() オブジェクトを作成します。

このオブジェクトは、client_secret.json ファイルの情報を使用してアプリケーションを識別します。（このファイルの詳細については、認証情報の作成をご覧ください）。このオブジェクトは、アプリケーションがアクセス権をリクエストしているスコープと、Google の OAuth 2.0 サーバーからのレスポンスを処理するアプリケーションの認証エンドポイントの URL も識別します。最後に、オプションの access_type パラメータと include_granted_scopes パラメータを設定します。

たとえば、次のコードは、ユーザーの YouTube アカウントを管理するためのオフライン アクセスをリクエストします。

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

次のコード スニペットは、google-auth-oauthlib.flow モジュールを使用して認可リクエストを作成します。

このコードは、認可認証情報の作成後にダウンロードした client_secret.json ファイルの情報を使用して、アプリケーションを識別する Flow オブジェクトを作成します。このオブジェクトは、アプリケーションがアクセス権をリクエストしているスコープと、Google の OAuth 2.0 サーバーからのレスポンスを処理するアプリケーションの認証エンドポイントの URL も識別します。最後に、コードは省略可能な access_type パラメータと include_granted_scopes パラメータを設定します。

たとえば、次のコードは、ユーザーの YouTube アカウントを管理するためのオフライン アクセスをリクエストします。

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

作成した client_secrets.json ファイルを使用して、アプリケーションでクライアント オブジェクトを構成します。クライアント オブジェクトを構成するときに、アプリケーションがアクセスする必要があるスコープと、OAuth 2.0 サーバーからのレスポンスを処理するアプリケーションの認証エンドポイントの URL を指定します。

たとえば、次のコードは、ユーザーの YouTube アカウントを管理するためのオフライン アクセスをリクエストします。

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)

アプリケーションは、クライアント オブジェクトを使用して、認可リクエスト URL の生成や HTTP リクエストへのアクセス トークンの適用などの OAuth 2.0 オペレーションを実行します。

次のコード スニペットは、認可リクエストのパラメータを定義する google.auth.OAuth2 オブジェクトを作成します。

このオブジェクトは、client_secret.json ファイルの情報を使用してアプリケーションを識別します。アクセス トークンを取得する権限をユーザーにリクエストするには、同意ページにリダイレクトします。同意ページの 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
  * 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
 });

重要な注意事項 - refresh_token は最初の認可時にのみ返されます。詳しくは、
こちらをご覧ください。

Google の OAuth 2.0 エンドポイントは https://accounts.google.com/o/oauth2/v2/auth にあります。このエンドポイントには HTTPS 経由でのみアクセスできます。プレーン HTTP 接続は拒否されます。

$auth_url = $client->createAuthUrl();

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

この例では、Flask ウェブ アプリケーション フレームワークを使用して、ユーザーを認可 URL にリダイレクトする方法を示します。

return flask.redirect(authorization_url)

auth_uri = authorizer.get_authorization_url(request: request)

res.redirect(authorizationUrl);

以下のサンプル URL は、ユーザーの YouTube アカウントを表示するためのアクセス権を許可するスコープへのオフライン アクセス（access_type=offline）をリクエストしています。増分認可を使用して、ユーザーが以前にアプリにアクセス権を付与したすべてのスコープが新しいアクセス トークンに含まれるようにします。URL では、必要な redirect_uri、response_type、client_id パラメータと state パラメータの値も設定します。URL には、読みやすくするために改行とスペースが含まれています。

 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

リクエスト URL を作成したら、ユーザーをその URL にリダイレクトします。

認可コードをアクセス トークンと交換するには、fetchAccessTokenWithAuthCode メソッドを使用します。

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

コールバック ページで、google-auth ライブラリを使用して認可サーバーのレスポンスを検証します。次に、flow.fetch_token メソッドを使用して、そのレスポンスの認証コードをアクセス トークンと交換します。

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}

コールバック ページで、googleauth ライブラリを使用して認可サーバーのレスポンスを検証します。authorizer.handle_auth_callback_deferred メソッドを使用して認証コードを保存し、最初に認証をリクエストした URL にリダイレクトします。これにより、結果を一時的にユーザーのセッションに保存することで、コードの交換が延期されます。

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

認可コードをアクセス トークンと交換するには、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);
 });

認証コードをアクセス トークンと交換するには、https://oauth2.googleapis.com/token エンドポイントを呼び出して、次のパラメータを設定します。

次のスニペットは、サンプル リクエストを示しています。

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 は、このリクエストに応答して、有効期間の短いアクセス トークンと更新トークンを含む JSON オブジェクトを返します。更新トークンは、アプリケーションが Google の認可サーバーの最初のリクエストで access_type パラメータを offline に設定した場合にのみ返されます。

レスポンスには、次のフィールドが含まれます。

次のスニペットは、サンプル レスポンスを示しています。

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

ユーザーが付与したスコープを確認するには、getGrantedScope() メソッドを使用します。

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

返された credentials オブジェクトには granted_scopes プロパティがあります。これは、ユーザーがアプリに付与したスコープのリストです。

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}

複数のスコープを一度にリクエストする場合は、credentials オブジェクトの scope プロパティで、どのスコープが付与されたかを確認します。

# 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

複数のスコープを一度にリクエストする場合は、tokens オブジェクトの scope プロパティで、どのスコープが付与されたかを確認します。

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

ユーザーがアプリケーションに特定のスコープへのアクセス権を付与しているかどうかを確認するには、アクセス トークン レスポンスの scope フィールドを確認します。access_token によって付与されたアクセス権のスコープ。スペース区切りの大文字と小文字を区別する文字列のリストとして表されます。

たとえば、次のアクセス トークン レスポンスの例は、ユーザーがアプリに、ユーザーの 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"
   }

アクセス トークンを使用して Google API を呼び出す手順は次のとおりです。

$client->setAccessToken($access_token);

$youtube = new Google_Service_YouTube($client);

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

アクセス トークンを取得した後、アプリケーションはそのトークンを使用して、特定のユーザー アカウントまたはサービス アカウントに代わって API リクエストを承認できます。ユーザー固有の認可認証情報を使用して、呼び出す API のサービス オブジェクトを作成し、そのオブジェクトを使用して承認済みの API リクエストを行います。

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

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

アクセス トークンを取得した後、アプリケーションはそのトークンを使用して、特定のユーザー アカウントまたはサービス アカウントに代わって API リクエストを送信できます。ユーザー固有の認可認証情報を使用して、呼び出す API のサービス オブジェクトを作成し、そのオブジェクトを使用して承認済みの API リクエストを行います。

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

youtube.authorization = credentials

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

または、メソッドに options パラメータを指定することで、メソッドごとに認可を提供することもできます。

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

アクセス トークンを取得して OAuth2 オブジェクトに設定したら、そのオブジェクトを使用して Google API を呼び出します。アプリケーションは、そのトークンを使用して、特定のユーザー アカウントまたはサービス アカウントに代わって API リクエストを承認できます。呼び出す API のサービス オブジェクトを作成します。たとえば、次のコードは Google Drive API を使用して、ユーザーのドライブ内のファイル名を一覧表示します。

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

アプリケーションがアクセス トークンを取得すると、API で必要なアクセス権が付与されている場合は、そのトークンを使用して特定のユーザー アカウントの代わりに Google API を呼び出すことができます。これを行うには、access_token クエリ パラメータまたは Authorization HTTP ヘッダー Bearer 値のいずれかを含めて、API へのリクエストにアクセス トークンを含めます。クエリ文字列はサーバーログに表示されるため、可能であれば HTTP ヘッダーを使用することをおすすめします。ほとんどの場合、クライアント ライブラリを使用して Google API の呼び出しを設定できます（YouTube Data API を呼び出す場合など）。

YouTube Data API は、複数の YouTube チャンネルを所有して管理している YouTube コンテンツ所有者（レコード レーベルや映画制作会社など）のサービス アカウントのみをサポートしています。

すべての Google API を試して、そのスコープを確認するには、OAuth 2.0 Playground をご覧ください。

Authorization: Bearer HTTP ヘッダーを使用して
youtube.channels エンドポイント（YouTube Data API）を呼び出すと、次のようになります。独自のアクセス トークンを指定する必要があります。

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

以下は、access_token クエリ文字列パラメータを使用して、認証済みユーザーの同じ API を呼び出すコードです。

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

これらのコマンドは、curl コマンドライン アプリケーションでテストできます。HTTP ヘッダー オプションを使用する例を次に示します（推奨）。

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

または、クエリ文字列パラメータ オプションを使用します。

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

この例を実行するには:

 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'];
 }
 ?>

この例では、Flask フレームワークを使用します。http://localhost:8080 でウェブ アプリケーションを実行し、OAuth 2.0 フローをテストできます。その URL にアクセスすると、次の 5 つのリンクが表示されます。

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

この例では、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

この例を実行するには:

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

この Python の例では、Flask フレームワークと Requests ライブラリを使用して、OAuth 2.0 ウェブフローを説明します。このフローには、Python 用 Google API クライアント ライブラリを使用することをおすすめします。（[Python] タブの例では、クライアント ライブラリを使用しています）。

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

Python では、include_granted_scopes キーワード引数を true に設定して、以前に付与されたスコープが認可リクエストに含まれるようにします。次の例に示すように、include_granted_scopes が設定する唯一のキーワード引数ではない可能性があります。

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

この例では、呼び出し元のアプリは、ユーザーがすでにアプリに付与している他のアクセス権に加えて、ユーザーの YouTube アナリティクス データを取得するためのアクセス権をリクエストします。

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

ユーザーがリクエストされたスコープへのオフライン アクセスを許可すると、ユーザーがオフラインの場合でも、API クライアントを使用してユーザーに代わって Google API にアクセスできます。クライアント オブジェクトは、必要に応じてアクセス トークンを更新します。

Python では、access_type キーワード引数を offline に設定して、権限を再度プロンプトすることなくアクセス トークンを更新できるようにします。次の例に示すように、access_type が設定する唯一のキーワード引数である可能性はほとんどありません。

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

ユーザーがリクエストされたスコープへのオフライン アクセスを許可すると、ユーザーがオフラインの場合でも、API クライアントを使用してユーザーに代わって Google API にアクセスできます。クライアント オブジェクトは、必要に応じてアクセス トークンを更新します。

アプリケーションで Google API へのオフライン アクセスが必要な場合は、API クライアントのアクセスタイプを offline に設定します。

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

ユーザーがリクエストされたスコープへのオフライン アクセスを許可すると、ユーザーがオフラインの場合でも、API クライアントを使用してユーザーに代わって Google API にアクセスできます。クライアント オブジェクトは、必要に応じてアクセス トークンを更新します。

アプリケーションで Google API へのオフライン アクセスが必要な場合は、API クライアントのアクセスタイプを 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
 });

ユーザーがリクエストされたスコープへのオフライン アクセスを許可すると、ユーザーがオフラインの場合でも、API クライアントを使用してユーザーに代わって Google API にアクセスできます。クライアント オブジェクトは、必要に応じてアクセス トークンを更新します。

アクセス トークンは期限切れになります。このライブラリは、有効期限が切れそうになると、自動的に更新トークンを使用して新しいアクセス トークンを取得します。常に最新のトークンを保存する簡単な方法は、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);
 });

このトークン イベントは最初の承認でのみ発生します。generateAuthUrl メソッドを呼び出して更新トークンを受け取るときに、access_type を offline に設定する必要があります。更新トークンの受信に適切な制約を設けずに、アプリに必要な権限をすでに付与している場合は、新しい更新トークンを受け取るためにアプリケーションを再承認する必要があります。

後で refresh_token を設定するには、setCredentials メソッドを使用します。

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

クライアントが更新トークンを取得すると、次回の API 呼び出しでアクセス トークンが取得され、自動的に更新されます。

アクセス トークンを更新するには、アプリケーションが Google の認可サーバーに HTTPS POST リクエストを送信します。このリクエストには、次のパラメータが含まれます。https://oauth2.googleapis.com/token


フィールド




client_id
API Consoleから取得したクライアント ID。


client_secret
API Consoleから取得したクライアント シークレット。


grant_type
OAuth 2.0 仕様で定義されているように、このフィールドの値は refresh_token に設定する必要があります。


refresh_token
認証コード交換から返された更新トークン。

次のスニペットは、サンプル リクエストを示しています。

 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

ユーザーがアプリケーションに付与されたアクセス権を取り消していない限り、トークン サーバーは新しいアクセス トークンを含む JSON オブジェクトを返します。次のスニペットは、サンプル レスポンスを示しています。

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

発行される更新トークンの数には上限があります。クライアントとユーザーの組み合わせごとに 1 つ、すべてのクライアントのユーザーごとに 1 つです。更新トークンは長期ストレージに保存し、有効である限り引き続き使用する必要があります。アプリがリフレッシュ トークンを過度にリクエストすると、これらの上限に達することがあります。その場合、古いリフレッシュ トークンは機能しなくなります。

トークンをプログラムで取り消すには、revokeToken() を呼び出します。

$client->revokeToken();

プログラムでトークンを取り消すには、トークンをパラメータとして含め、Content-Type ヘッダーを設定して https://oauth2.googleapis.com/revoke にリクエストを送信します。

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

プログラムでトークンを取り消すには、oauth2.revoke エンドポイントに HTTP リクエストを送信します。

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

トークンは、アクセス トークンまたは更新トークンです。トークンがアクセス トークンで、対応する更新トークンがある場合、更新トークンも取り消されます。

取り消しが正常に処理された場合、レスポンスのステータス コードは 200 です。エラー状態の場合、ステータス コード 400 がエラーコードとともに返されます。

プログラムでトークンを取り消すには、/revoke エンドポイントに対して HTTPS POST リクエストを送信します。

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

token パラメータには、アクセス トークンまたは更新トークンを指定できます。トークンがアクセス トークンで、対応する更新トークンがある場合、更新トークンも取り消されます。

取り消しが正常に処理された場合、レスポンスのステータス コードは 200 です。エラー状態の場合、ステータス コード 400 がエラーコードとともに返されます。

プログラムでトークンを取り消すには、アプリが https://oauth2.googleapis.com/revoke にリクエストを行い、トークンをパラメータとして含めます。

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

トークンは、アクセス トークンまたは更新トークンです。トークンがアクセス トークンで、対応する更新トークンがある場合、更新トークンも取り消されます。

取り消しが正常に処理されると、レスポンスの HTTP ステータス コードは 200 になります。エラー状態の場合、エラーコードとともに HTTP ステータス コード 400 が返されます。