वेब सर्वर ऐप्लिकेशन के लिए OAuth 2.0 का इस्तेमाल करना

इस दस्तावेज़ में बताया गया है कि वेब सर्वर ऐप्लिकेशन, YouTube Data API को ऐक्सेस करने के लिए, OAuth 2.0 की अनुमति देने के लिए, Google API क्लाइंट लाइब्रेरी या Google OAuth 2.0 एंडपॉइंट का इस्तेमाल कैसे करते हैं.

OAuth 2.0 की मदद से, उपयोगकर्ता अपने उपयोगकर्ता नाम, पासवर्ड, और अन्य जानकारी को निजी रखते हुए, किसी ऐप्लिकेशन के साथ खास डेटा शेयर कर सकते हैं. उदाहरण के लिए, कोई ऐप्लिकेशन OAuth 2.0 का इस्तेमाल करके, उपयोगकर्ता के YouTube चैनल पर वीडियो अपलोड करने की अनुमति पा सकता है.

यह OAuth 2.0 फ़्लो, खास तौर पर उपयोगकर्ता की अनुमति के लिए है. इसे उन ऐप्लिकेशन के लिए डिज़ाइन किया गया है जो गोपनीय जानकारी को सेव कर सकते हैं और उसकी स्थिति को बनाए रख सकते हैं. सही तरीके से अनुमति पा चुका वेब सर्वर ऐप्लिकेशन, उपयोगकर्ता के ऐप्लिकेशन से इंटरैक्ट करने के दौरान या उपयोगकर्ता के ऐप्लिकेशन से बाहर निकलने के बाद, किसी एपीआई को ऐक्सेस कर सकता है.

वेब सर्वर ऐप्लिकेशन, एपीआई अनुरोधों को अनुमति देने के लिए अक्सर सेवा खातों का भी इस्तेमाल करते हैं. ऐसा खास तौर पर तब किया जाता है, जब उपयोगकर्ता के डेटा के बजाय प्रोजेक्ट के डेटा को ऐक्सेस करने के लिए, Cloud API को कॉल किया जाता है. वेब सर्वर ऐप्लिकेशन, उपयोगकर्ता की अनुमति के साथ सेवा खातों का इस्तेमाल कर सकते हैं. ध्यान दें कि YouTube Data API, सिर्फ़ उन YouTube कॉन्टेंट के मालिकों के लिए सेवा खाते के फ़्लो का इस्तेमाल करता है जिनके पास एक से ज़्यादा YouTube चैनलों का मालिकाना हक है और जिन्हें मैनेज करने का अधिकार है. खास तौर पर, कॉन्टेंट के मालिक सेवा खातों का इस्तेमाल करके, onBehalfOfContentOwner अनुरोध पैरामीटर के साथ काम करने वाले एपीआई तरीकों को कॉल कर सकते हैं.

क्लाइंट लाइब्रेरी

इस पेज पर, भाषा के हिसाब से दिए गए उदाहरणों में, OAuth 2.0 की अनुमति देने की सुविधा को लागू करने के लिए, Google API क्लाइंट लाइब्रेरी का इस्तेमाल किया गया है. कोड सैंपल चलाने के लिए, आपको सबसे पहले अपनी भाषा के लिए क्लाइंट लाइब्रेरी इंस्टॉल करनी होगी.

अपने ऐप्लिकेशन के OAuth 2.0 फ़्लो को मैनेज करने के लिए, Google API क्लाइंट लाइब्रेरी का इस्तेमाल करने पर, क्लाइंट लाइब्रेरी कई कार्रवाइयां करती है. आम तौर पर, ये कार्रवाइयां ऐप्लिकेशन को खुद करनी होती हैं. उदाहरण के लिए, यह तय करता है कि ऐप्लिकेशन, सेव किए गए ऐक्सेस टोकन का इस्तेमाल कब कर सकता है या उन्हें कब रीफ़्रेश कर सकता है. साथ ही, यह भी तय करता है कि ऐप्लिकेशन को सहमति फिर से कब लेनी होगी. क्लाइंट लाइब्रेरी, सही रीडायरेक्ट यूआरएल भी जनरेट करती है. साथ ही, रीडायरेक्ट हैंडलर को लागू करने में मदद करती है, जो ऑथराइज़ेशन कोड को ऐक्सेस टोकन के लिए एक्सचेंज करते हैं.

सर्वर-साइड ऐप्लिकेशन के लिए, Google API की क्लाइंट लाइब्रेरी इन भाषाओं में उपलब्ध हैं:

ज़रूरी शर्तें

अपने प्रोजेक्ट के लिए एपीआई चालू करना

Google API को कॉल करने वाले किसी भी ऐप्लिकेशन को, उन एपीआई को API Consoleमें चालू करना होगा.

अपने प्रोजेक्ट के लिए एपीआई चालू करने के लिए:

  1. Open the API Library में Google API Console.
  2. If prompted, select a project, or create a new one.
  3. YouTube Data API ढूंढने और उसे चालू करने के लिए, लाइब्रेरी पेज का इस्तेमाल करें. ऐसे अन्य एपीआई ढूंढें जिनका इस्तेमाल आपका ऐप्लिकेशन करेगा और उन्हें भी चालू करें.

अनुमति देने वाले क्रेडेंशियल बनाना

Google के एपीआई को ऐक्सेस करने के लिए OAuth 2.0 का इस्तेमाल करने वाले किसी भी ऐप्लिकेशन के पास, अनुमति देने वाले ऐसे क्रेडेंशियल होने चाहिए जिनसे Google के OAuth 2.0 सर्वर को ऐप्लिकेशन की पहचान की जा सके. यहां अपने प्रोजेक्ट के लिए क्रेडेंशियल बनाने का तरीका बताया गया है. इसके बाद, आपके ऐप्लिकेशन उन एपीआई को ऐक्सेस करने के लिए क्रेडेंशियल का इस्तेमाल कर सकते हैं जिन्हें आपने उस प्रोजेक्ट के लिए चालू किया है.

  1. Go to the Credentials page.
  2. क्रेडेंशियल बनाएं > OAuth क्लाइंट आईडी पर क्लिक करें.
  3. वेब ऐप्लिकेशन ऐप्लिकेशन टाइप चुनें.
  4. फ़ॉर्म भरें और बनाएं पर क्लिक करें. PHP, Java, Python, Ruby, और .NET जैसी भाषाओं और फ़्रेमवर्क का इस्तेमाल करने वाले ऐप्लिकेशन को, अनुमति वाले रीडायरेक्ट यूआरआई की जानकारी देनी होगी. रीडायरेक्ट यूआरआई, ऐसे एंडपॉइंट होते हैं जिन पर OAuth 2.0 सर्वर जवाब भेज सकता है. इन एंडपॉइंट को पुष्टि करने के Google के नियमों का पालन करना होगा.

    जांच करने के लिए, ऐसे यूआरआई तय किए जा सकते हैं जो लोकल मशीन से जुड़े हों, जैसे कि http://localhost:8080. इस बात को ध्यान में रखते हुए, कृपया ध्यान दें कि इस दस्तावेज़ में दिए गए सभी उदाहरणों में, रीडायरेक्ट यूआरआई के तौर पर http://localhost:8080 का इस्तेमाल किया गया है.

    हमारा सुझाव है कि आप अपने ऐप्लिकेशन के पुष्टि करने वाले एंडपॉइंट को डिज़ाइन करें, ताकि आपका ऐप्लिकेशन, पेज पर मौजूद अन्य संसाधनों को अनुमति कोड न दिखाए.

क्रेडेंशियल बनाने के बाद, API Consoleसे client_secret.json फ़ाइल डाउनलोड करें. फ़ाइल को ऐसी जगह पर सुरक्षित तरीके से सेव करें जहां से सिर्फ़ आपका ऐप्लिकेशन उसे ऐक्सेस कर सके.

ऐक्सेस के स्कोप की पहचान करना

स्कोप की मदद से, आपके ऐप्लिकेशन को सिर्फ़ उन संसाधनों का ऐक्सेस पाने का अनुरोध करने की सुविधा मिलती है जिनकी उसे ज़रूरत होती है. साथ ही, इससे उपयोगकर्ताओं को यह कंट्रोल करने की सुविधा भी मिलती है कि वे आपके ऐप्लिकेशन को कितना ऐक्सेस दें. इसलिए, अनुरोध किए गए स्कोप की संख्या और उपयोगकर्ता की सहमति पाने की संभावना के बीच उलटा संबंध हो सकता है.

हमारा सुझाव है कि OAuth 2.0 ऑथराइज़ेशन लागू करने से पहले, उन स्कोप की पहचान करें जिन्हें ऐक्सेस करने के लिए आपके ऐप्लिकेशन को अनुमति की ज़रूरत होगी.

हमारा सुझाव है कि आपका ऐप्लिकेशन, अनुमति के दायरों का ऐक्सेस पाने के लिए, ज़्यादा अनुमति की प्रोसेस का इस्तेमाल करे. इस प्रोसेस में, आपका ऐप्लिकेशन उपयोगकर्ता के डेटा को संदर्भ के हिसाब से ऐक्सेस करने का अनुरोध करता है. इस सबसे सही तरीके से, उपयोगकर्ताओं को यह समझने में मदद मिलती है कि आपके ऐप्लिकेशन को जिस ऐक्सेस का अनुरोध करना है उसकी ज़रूरत क्यों है.

YouTube Data API v3, इन स्कोप का इस्तेमाल करता है:

बंदूक पर लगने वाली दूरबीन
https://www.googleapis.com/auth/youtubeअपना YouTube खाता मैनेज करें
https://www.googleapis.com/auth/youtube.channel-memberships.creatorअपने चैनल के मौजूदा सक्रिय सदस्यों की सूची और उनका मौजूदा लेवल देखें. यह भी देखें कि वे चैनल के सदस्य कब बने
https://www.googleapis.com/auth/youtube.force-sslअपने YouTube वीडियो की रेटिंग, टिप्पणियां और कैप्शन देखें, उनमें बदलाव करें और उन्हें हमेशा के लिए मिटाएं
https://www.googleapis.com/auth/youtube.readonlyअपना YouTube खाता देखें
https://www.googleapis.com/auth/youtube.uploadअपने YouTube वीडियो मैनेज करें
https://www.googleapis.com/auth/youtubepartnerYouTube पर अपनी परिसंपत्ति तथा संबंधित सामग्री देखें व प्रबंधित करें
https://www.googleapis.com/auth/youtubepartner-channel-auditकिसी YouTube भागीदार की ऑडिट प्रक्रिया के दौरान उससे प्रासंगिक अपने YouTube चैनल की निजी जानकारी देखें

OAuth 2.0 एपीआई स्कोप दस्तावेज़ में, उन स्कोप की पूरी सूची होती है जिनका इस्तेमाल Google API को ऐक्सेस करने के लिए किया जा सकता है.

भाषा के हिसाब से ज़रूरी शर्तें

इस दस्तावेज़ में दिए गए किसी भी कोड सैंपल को चलाने के लिए, आपके पास Google खाता, इंटरनेट का ऐक्सेस, और वेब ब्राउज़र होना चाहिए. अगर किसी एपीआई क्लाइंट लाइब्रेरी का इस्तेमाल किया जा रहा है, तो भाषा के हिसाब से ज़रूरी शर्तें भी देखें.

PHP

इस दस्तावेज़ में PHP कोड के सैंपल चलाने के लिए, आपको इन चीज़ों की ज़रूरत होगी:

  • कमांड-लाइन इंटरफ़ेस (सीएलआई) और JSON एक्सटेंशन के साथ PHP 8.0 या इसके बाद का वर्शन.
  • Composer डिपेंडेंसी मैनेजमेंट टूल.

  • PHP के लिए Google APIs क्लाइंट लाइब्रेरी:

    composer require google/apiclient:^2.15.0

ज़्यादा जानकारी के लिए, PHP के लिए Google API की क्लाइंट लाइब्रेरी देखें.

Python

इस दस्तावेज़ में दिए गए Python कोड के सैंपल चलाने के लिए, आपके पास ये चीज़ें होनी चाहिए:

  • Python 3.7 या इसके बाद का वर्शन
  • pip पैकेज मैनेजमेंट टूल.
  • Python 2.0 के लिए Google API क्लाइंट लाइब्रेरी की रिलीज़: 
    pip install --upgrade google-api-python-client
  • उपयोगकर्ता की अनुमति के लिए google-auth, google-auth-oauthlib, और google-auth-httplib2. 
    pip install --upgrade google-auth google-auth-oauthlib google-auth-httplib2
  • Flask Python वेब ऐप्लिकेशन फ़्रेमवर्क. 
    pip install --upgrade flask
  • requests एचटीटीपी लाइब्रेरी. 
    pip install --upgrade requests

अगर आपको Python और उससे जुड़ी माइग्रेशन गाइड को अपग्रेड करने में समस्या आ रही है, तो Google API की Python क्लाइंट लाइब्रेरी के रिलीज़ नोट को पढ़ें.

Ruby

इस दस्तावेज़ में दिए गए Ruby कोड सैंपल चलाने के लिए, आपके पास ये चीज़ें होनी चाहिए:

  • Ruby 2.6 या इसके बाद का वर्शन

  • Ruby के लिए Google Auth लाइब्रेरी:

    gem install googleauth

  • Sinatra Ruby वेब ऐप्लिकेशन फ़्रेमवर्क.

    gem install sinatra

Node.js

इस दस्तावेज़ में दिए गए Node.js कोड सैंपल चलाने के लिए, आपको इन चीज़ों की ज़रूरत होगी:

  • Node.js का रखरखाव वाला LTS, चालू LTS या मौजूदा रिलीज़.

  • Google APIs का Node.js क्लाइंट:

    npm install googleapis crypto express express-session

एचटीटीपी/REST

OAuth 2.0 एंडपॉइंट को सीधे तौर पर कॉल करने के लिए, आपको कोई लाइब्रेरी इंस्टॉल करने की ज़रूरत नहीं है.

OAuth 2.0 ऐक्सेस टोकन पाना

यहां दिए गए चरणों से पता चलता है कि आपका ऐप्लिकेशन, उपयोगकर्ता की ओर से एपीआई अनुरोध करने के लिए, उसकी सहमति पाने के लिए, Google के OAuth 2.0 सर्वर के साथ कैसे इंटरैक्ट करता है. Google API का ऐसा अनुरोध पूरा करने से पहले, आपके ऐप्लिकेशन के पास वह अनुमति होनी चाहिए जिसके लिए उपयोगकर्ता की अनुमति की ज़रूरत होती है.

नीचे दी गई सूची में, इन चरणों के बारे में खास जानकारी दी गई है:

  1. आपका ऐप्लिकेशन उन अनुमतियों की पहचान करता है जिनकी उसे ज़रूरत है.
  2. आपका ऐप्लिकेशन, उपयोगकर्ता को Google पर रीडायरेक्ट करता है. साथ ही, अनुरोध की गई अनुमतियों की सूची भी भेजता है.
  3. उपयोगकर्ता यह तय करता है कि आपके ऐप्लिकेशन को अनुमतियां देनी हैं या नहीं.
  4. आपके ऐप्लिकेशन को पता चल जाता है कि उपयोगकर्ता ने क्या फ़ैसला लिया है.
  5. अगर उपयोगकर्ता ने अनुरोध की गई अनुमतियां दी हैं, तो आपका ऐप्लिकेशन उपयोगकर्ता की ओर से एपीआई अनुरोध करने के लिए ज़रूरी टोकन हासिल करता है.

पहला चरण: अनुमति देने वाले पैरामीटर सेट करना

सबसे पहले, आपको अनुमति का अनुरोध बनाना होगा. इस अनुरोध से ऐसे पैरामीटर सेट होते हैं जिनसे आपके ऐप्लिकेशन की पहचान होती है. साथ ही, यह भी तय होता है कि उपयोगकर्ता को आपके ऐप्लिकेशन को कौनसी अनुमतियां देनी होंगी.

  • अगर OAuth 2.0 की पुष्टि और अनुमति के लिए Google क्लाइंट लाइब्रेरी का इस्तेमाल किया जाता है, तो आपको ऐसा ऑब्जेक्ट बनाना और कॉन्फ़िगर करना होगा जो इन पैरामीटर को तय करता है.
  • Google OAuth 2.0 एंडपॉइंट को सीधे कॉल करने पर, आपको एक यूआरएल जनरेट होगा और उस यूआरएल पर पैरामीटर सेट करने होंगे.

नीचे दिए गए टैब में, वेब सर्वर ऐप्लिकेशन के लिए अनुमति वाले पैरामीटर के बारे में बताया गया है. भाषा के हिसाब से दिए गए उदाहरणों में, उन पैरामीटर को सेट करने वाले ऑब्जेक्ट को कॉन्फ़िगर करने के लिए, क्लाइंट लाइब्रेरी या अनुमति लाइब्रेरी का इस्तेमाल करने का तरीका भी बताया गया है.

PHP

यहां दिया गया कोड स्निपेट, Google\Client() ऑब्जेक्ट बनाता है. यह ऑब्जेक्ट, अनुमति के अनुरोध में पैरामीटर तय करता है.

यह ऑब्जेक्ट, आपके ऐप्लिकेशन की पहचान करने के लिए, आपकी client_secret.json फ़ाइल की जानकारी का इस्तेमाल करता है. (इस फ़ाइल के बारे में ज़्यादा जानने के लिए, अनुमति क्रेडेंशियल बनाना देखें.) इस ऑब्जेक्ट से उन स्कोप की भी पहचान होती है जिन्हें ऐक्सेस करने की अनुमति पाने के लिए आपका ऐप्लिकेशन अनुरोध कर रहा है. साथ ही, इससे आपके ऐप्लिकेशन के ऑथराइज़ेशन एंडपॉइंट का यूआरएल भी पता चलता है. यह यूआरएल, Google के OAuth 2.0 सर्वर से मिले जवाब को मैनेज करेगा. आखिर में, कोड वैकल्पिक 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);

Python

नीचे दिया गया कोड स्निपेट, अनुमति का अनुरोध बनाने के लिए google-auth-oauthlib.flow मॉड्यूल का इस्तेमाल करता है.

यह कोड एक Flow ऑब्जेक्ट बनाता है, जो client_secret.json फ़ाइल की जानकारी का इस्तेमाल करके आपके ऐप्लिकेशन की पहचान करता है. यह फ़ाइल, अनुमति के क्रेडेंशियल बनाने के बाद डाउनलोड की जाती है. उस ऑब्जेक्ट से उन स्कोप की भी पहचान की जाती है जिन्हें ऐक्सेस करने की अनुमति आपके ऐप्लिकेशन ने मांगी है. साथ ही, उसमें आपके ऐप्लिकेशन के ऑथराइज़ेशन एंडपॉइंट का यूआरएल भी शामिल होता है. यह यूआरएल, Google के OAuth 2.0 सर्वर से मिलने वाले जवाब को मैनेज करेगा. आखिर में, कोड वैकल्पिक 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')

Ruby

अपने ऐप्लिकेशन में क्लाइंट ऑब्जेक्ट को कॉन्फ़िगर करने के लिए, आपने जो client_secrets.json फ़ाइल बनाई है उसका इस्तेमाल करें. क्लाइंट ऑब्जेक्ट को कॉन्फ़िगर करते समय, आपको उन स्कोप की जानकारी देनी होती है जिन्हें आपके ऐप्लिकेशन को ऐक्सेस करना है. साथ ही, आपको अपने ऐप्लिकेशन के ऑथराइज़ेशन एंडपॉइंट के यूआरएल की जानकारी भी देनी होती है. यह एंडपॉइंट, OAuth 2.0 सर्वर से मिले रिस्पॉन्स को मैनेज करेगा.

उदाहरण के लिए, यह कोड किसी उपयोगकर्ता के 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)

आपका ऐप्लिकेशन, OAuth 2.0 से जुड़े ऑपरेशन करने के लिए क्लाइंट ऑब्जेक्ट का इस्तेमाल करता है. जैसे, अनुमति के अनुरोध के यूआरएल जनरेट करना और एचटीटीपी अनुरोधों में ऐक्सेस टोकन लागू करना.

Node.js

यहां दिया गया कोड स्निपेट, google.auth.OAuth2 ऑब्जेक्ट बनाता है. यह ऑब्जेक्ट, अनुमति के अनुरोध में पैरामीटर तय करता है.

यह ऑब्जेक्ट, आपके ऐप्लिकेशन की पहचान करने के लिए, आपकी client_secret.json फ़ाइल की जानकारी का इस्तेमाल करता है. ऐक्सेस टोकन पाने के लिए, उपयोगकर्ता से अनुमतियां मांगने के लिए, उसे सहमति वाले पेज पर रीडायरेक्ट किया जाता है. सहमति वाले पेज का यूआरएल बनाने के लिए: 

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 सिर्फ़ पहली अनुमति पर दिखाया जाता है. ज़्यादा जानकारी के लिए यहां जाएं.

एचटीटीपी/REST

Google का OAuth 2.0 एंडपॉइंट https://accounts.google.com/o/oauth2/v2/auth पर है. इस एंडपॉइंट को सिर्फ़ एचटीटीपीएस के ज़रिए ऐक्सेस किया जा सकता है. साधारण एचटीटीपी कनेक्शन अस्वीकार कर दिए जाते हैं.

Google का ऑथराइज़ेशन सर्वर, वेब सर्वर ऐप्लिकेशन के लिए इन क्वेरी स्ट्रिंग पैरामीटर के साथ काम करता है:

पैरामीटर
client_id ज़रूरी है

आपके ऐप्लिकेशन का क्लाइंट आईडी. यह वैल्यू आपको API Console Credentials pageमें दिखेगी.
redirect_uri ज़रूरी है

यह तय करता है कि उपयोगकर्ता अनुमति पाने का फ़्लो पूरा करने के बाद, एपीआई सर्वर उसे कहां रीडायरेक्ट करेगा. यह वैल्यू, OAuth 2.0 क्लाइंट के लिए अनुमति वाले रीडायरेक्ट यूआरआई से पूरी तरह मेल खानी चाहिए. आपने अपने क्लाइंट के API Console Credentials pageमें इसे कॉन्फ़िगर किया है. अगर यह वैल्यू, दिए गए client_id के लिए अनुमति वाले रीडायरेक्ट यूआरआई से मेल नहीं खाती है, तो आपको redirect_uri_mismatch गड़बड़ी का मैसेज मिलेगा.

ध्यान दें कि http या https स्कीम, केस, और आखिरी स्लैश (/) एक जैसे होने चाहिए.
response_type ज़रूरी है

इससे यह पता चलता है कि Google OAuth 2.0 एंडपॉइंट, ऑथराइज़ेशन कोड दिखाता है या नहीं.

वेब सर्वर ऐप्लिकेशन के लिए, पैरामीटर की वैल्यू को code पर सेट करें.
scope ज़रूरी है

स्पेस से अलग किए गए स्कोप की सूची, जो उन संसाधनों की पहचान करती है जिन्हें आपका ऐप्लिकेशन उपयोगकर्ता की ओर से ऐक्सेस कर सकता है. इन वैल्यू से, सहमति वाली उस स्क्रीन के बारे में पता चलता है जिसे Google, उपयोगकर्ता को दिखाता है.

स्कोप की मदद से, आपका ऐप्लिकेशन सिर्फ़ उन संसाधनों का ऐक्सेस पाने का अनुरोध कर सकता है जिनकी उसे ज़रूरत है. साथ ही, उपयोगकर्ताओं को यह कंट्रोल करने की सुविधा मिलती है कि वे आपके ऐप्लिकेशन को कितना ऐक्सेस दें. इसलिए, अनुरोध किए गए स्कोप की संख्या और उपयोगकर्ता की सहमति मिलने की संभावना के बीच उलटा संबंध होता है.

YouTube Data API v3, इन स्कोप का इस्तेमाल करता है:

बंदूक पर लगने वाली दूरबीन
https://www.googleapis.com/auth/youtubeअपना YouTube खाता मैनेज करें
https://www.googleapis.com/auth/youtube.channel-memberships.creatorअपने चैनल के मौजूदा सक्रिय सदस्यों की सूची और उनका मौजूदा लेवल देखें. यह भी देखें कि वे चैनल के सदस्य कब बने
https://www.googleapis.com/auth/youtube.force-sslअपने YouTube वीडियो की रेटिंग, टिप्पणियां और कैप्शन देखें, उनमें बदलाव करें और उन्हें हमेशा के लिए मिटाएं
https://www.googleapis.com/auth/youtube.readonlyअपना YouTube खाता देखें
https://www.googleapis.com/auth/youtube.uploadअपने YouTube वीडियो मैनेज करें
https://www.googleapis.com/auth/youtubepartnerYouTube पर अपनी परिसंपत्ति तथा संबंधित सामग्री देखें व प्रबंधित करें
https://www.googleapis.com/auth/youtubepartner-channel-auditकिसी YouTube भागीदार की ऑडिट प्रक्रिया के दौरान उससे प्रासंगिक अपने YouTube चैनल की निजी जानकारी देखें

OAuth 2.0 API के स्कोप दस्तावेज़ में, उन स्कोप की पूरी सूची दी गई है जिनका इस्तेमाल करके Google API को ऐक्सेस किया जा सकता है.

हमारा सुझाव है कि आपका ऐप्लिकेशन, अनुमति के दायरों को ऐक्सेस करने का अनुरोध, संदर्भ के हिसाब से करे. बढ़ती हुई अनुमति की मदद से, ज़रूरत के मुताबिक उपयोगकर्ता के डेटा को ऐक्सेस करने का अनुरोध करने पर, उपयोगकर्ताओं को यह समझने में आसानी होती है कि आपके ऐप्लिकेशन को जिस डेटा का ऐक्सेस चाहिए उसकी ज़रूरत क्यों है.
access_type सुझाया गया

इससे पता चलता है कि जब उपयोगकर्ता ब्राउज़र पर मौजूद न हो, तो आपका ऐप्लिकेशन ऐक्सेस टोकन रीफ़्रेश कर सकता है या नहीं. पैरामीटर की मान्य वैल्यू online और offline हैं. online, डिफ़ॉल्ट वैल्यू है.

अगर उपयोगकर्ता ब्राउज़र पर मौजूद न होने पर, आपके ऐप्लिकेशन को ऐक्सेस टोकन रीफ़्रेश करने की ज़रूरत है, तो वैल्यू को offline पर सेट करें. इस दस्तावेज़ में बाद में, ऐक्सेस टोकन को रीफ़्रेश करने का तरीका बताया गया है. इस वैल्यू से Google के ऑथराइज़ेशन सर्वर को निर्देश मिलता है कि जब भी आपका ऐप्लिकेशन, टोकन के लिए ऑथराइज़ेशन कोड का इस्तेमाल करे, तो वह रीफ़्रेश टोकन और ऐक्सेस टोकन दिखाए.
state सुझाया गया

इस एट्रिब्यूट की वैल्यू, स्ट्रिंग होती है. आपका ऐप्लिकेशन, अनुमति के अनुरोध और अनुमति देने वाले सर्वर के जवाब के बीच स्थिति बनाए रखने के लिए, इस वैल्यू का इस्तेमाल करता है. उपयोगकर्ता आपके ऐप्लिकेशन के ऐक्सेस अनुरोध को स्वीकार करने या अस्वीकार करने के बाद, सर्वर वही वैल्यू दिखाता है जो आपने redirect_uri के यूआरएल क्वेरी कॉम्पोनेंट (?) में name=value पेयर के तौर पर भेजी थी.

इस पैरामीटर का इस्तेमाल कई कामों के लिए किया जा सकता है. जैसे, उपयोगकर्ता को अपने ऐप्लिकेशन में सही संसाधन पर ले जाना, नॉन्स भेजना, और किसी दूसरी साइट से किए गए फ़र्ज़ी अनुरोध को कम करना. आपके redirect_uri का अनुमान लगाया जा सकता है. इसलिए, state वैल्यू का इस्तेमाल करने से, आपको यह पक्का करने में मदद मिल सकती है कि कोई इनकमिंग कनेक्शन, पुष्टि करने के अनुरोध की वजह से है. अगर कोई रैंडम स्ट्रिंग जनरेट की जाती है या कुकी के हैश को कोड में बदला जाता है या क्लाइंट की स्थिति को कैप्चर करने वाली कोई दूसरी वैल्यू को कोड में बदला जाता है, तो रिस्पॉन्स की पुष्टि की जा सकती है. साथ ही, यह भी पक्का किया जा सकता है कि अनुरोध और रिस्पॉन्स, एक ही ब्राउज़र से शुरू हुए हैं. इससे क्रॉस-साइट अनुरोध के तौर पर फ़र्ज़ी अनुरोध जैसे हमलों से सुरक्षा मिलती है. state टोकन बनाने और उसकी पुष्टि करने का उदाहरण देखने के लिए, OpenID Connect के दस्तावेज़ देखें.
include_granted_scopes ज़रूरी नहीं

इससे ऐप्लिकेशन, ज़रूरत के मुताबिक अनुमति का इस्तेमाल करके, कॉन्टेक्स्ट में ज़्यादा स्कोप के ऐक्सेस का अनुरोध कर सकते हैं. अगर इस पैरामीटर की वैल्यू को true पर सेट किया जाता है और अनुमति का अनुरोध स्वीकार कर लिया जाता है, तो नया ऐक्सेस टोकन उन सभी स्कोप को भी कवर करेगा जिनके लिए उपयोगकर्ता ने पहले ऐप्लिकेशन को ऐक्सेस दिया था. उदाहरणों के लिए, इंक्रीमेंटल अनुमति सेक्शन देखें.
login_hint ज़रूरी नहीं

अगर आपके ऐप्लिकेशन को पता है कि कौनसा उपयोगकर्ता पुष्टि करने की कोशिश कर रहा है, तो वह Google Authentication Server को संकेत देने के लिए, इस पैरामीटर का इस्तेमाल कर सकता है. सर्वर, संकेत का इस्तेमाल करके साइन इन फ़ॉर्म में ईमेल फ़ील्ड को पहले से भरकर या एक से ज़्यादा लॉगिन सेशन में से सही सेशन चुनकर, लॉगिन फ़्लो को आसान बनाता है.

पैरामीटर की वैल्यू को किसी ईमेल पते या sub आइडेंटिफ़ायर पर सेट करें. यह वैल्यू, उपयोगकर्ता के Google आईडी के बराबर होती है.
prompt ज़रूरी नहीं

उपयोगकर्ता को दिखाने के लिए, स्पेस से अलग की गई, केस-सेंसिटिव प्रॉम्प्ट की सूची. अगर आपने इस पैरामीटर की वैल्यू नहीं दी है, तो उपयोगकर्ता को सिर्फ़ तब अनुरोध मिलेगा, जब आपका प्रोजेक्ट पहली बार ऐक्सेस का अनुरोध करेगा. ज़्यादा जानकारी के लिए, फिर से सहमति देने के लिए कहा जा रहा है देखें.

संभावित वैल्यू ये हैं:

none पुष्टि करने या सहमति देने के लिए कोई स्क्रीन न दिखाएं. इसे किसी दूसरी वैल्यू के साथ नहीं दिया जाना चाहिए.
consent उपयोगकर्ता से सहमति मांगें.
select_account उपयोगकर्ता से कोई खाता चुनने के लिए कहें.

दूसरा चरण: Google के OAuth 2.0 सर्वर पर रीडायरेक्ट करना

पुष्टि करने और अनुमति देने की प्रोसेस शुरू करने के लिए, उपयोगकर्ता को Google के OAuth 2.0 सर्वर पर रीडायरेक्ट करें. आम तौर पर, ऐसा तब होता है, जब आपके ऐप्लिकेशन को पहली बार उपयोगकर्ता का डेटा ऐक्सेस करना हो. बढ़ती अनुमति के मामले में, यह चरण तब भी होता है, जब आपके ऐप्लिकेशन को पहले ऐसे अतिरिक्त संसाधनों को ऐक्सेस करना पड़ता है जिनका ऐक्सेस उसके पास अब तक नहीं है.

PHP

  1. Google के OAuth 2.0 सर्वर से ऐक्सेस का अनुरोध करने के लिए, यूआरएल जनरेट करें: 
    $auth_url = $client->createAuthUrl();
  2. उपयोगकर्ता को $auth_url पर रीडायरेक्ट करें: 
    header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));

Python

इस उदाहरण में, Flask वेब ऐप्लिकेशन फ़्रेमवर्क का इस्तेमाल करके, उपयोगकर्ता को अनुमति वाले यूआरएल पर रीडायरेक्ट करने का तरीका बताया गया है:

return flask.redirect(authorization_url)

Ruby

  1. Google के OAuth 2.0 सर्वर से ऐक्सेस का अनुरोध करने के लिए, यूआरएल जनरेट करें: 
    auth_uri = authorizer.get_authorization_url(request: request)
  2. उपयोगकर्ता को auth_uri पर रीडायरेक्ट करें.

Node.js

  1. Google के OAuth 2.0 सर्वर से ऐक्सेस का अनुरोध करने के लिए, पहले चरण generateAuthUrl में जनरेट किए गए यूआरएल authorizationUrl का इस्तेमाल करें.
  2. उपयोगकर्ता को authorizationUrl पर रीडायरेक्ट करें. 
    res.redirect(authorizationUrl);

एचटीटीपी/REST

Google के अनुमति देने वाले सर्वर पर रीडायरेक्ट करने का सैंपल

यहां दिए गए सैंपल यूआरएल में, किसी ऐसे स्कोप के लिए ऑफ़लाइन ऐक्सेस (access_type=offline) का अनुरोध किया गया है जिससे उपयोगकर्ता के YouTube खाते को देखा जा सकता है. यह इंक्रीमेंटल अनुमति का इस्तेमाल करके यह पक्का करता है कि नया ऐक्सेस टोकन, उन सभी स्कोप को कवर करता है जिनके लिए उपयोगकर्ता ने पहले ऐप्लिकेशन को ऐक्सेस दिया था. यूआरएल, ज़रूरी redirect_uri, response_type, और client_id पैरामीटर के साथ-साथ state पैरामीटर के लिए भी वैल्यू सेट करता है. यूआरएल को आसानी से पढ़ा जा सके, इसके लिए उसमें लाइन ब्रेक और स्पेस शामिल किए गए हैं.

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

अनुरोध का यूआरएल बनाने के बाद, उपयोगकर्ता को उस पर रीडायरेक्ट करें.

Google का OAuth 2.0 सर्वर, उपयोगकर्ता की पुष्टि करता है. साथ ही, आपके ऐप्लिकेशन के लिए अनुरोध किए गए स्कोप ऐक्सेस करने की सहमति भी लेता है. आपके बताए गए रीडायरेक्ट यूआरएल का इस्तेमाल करके, जवाब को आपके ऐप्लिकेशन पर भेजा जाता है.

तीसरा चरण: Google, उपयोगकर्ता से सहमति मांगता है

इस चरण में, उपयोगकर्ता यह तय करता है कि आपके ऐप्लिकेशन को अनुरोध किया गया ऐक्सेस देना है या नहीं. इस चरण में, Google एक सहमति वाली विंडो दिखाता है. इसमें आपके ऐप्लिकेशन का नाम और Google API की उन सेवाओं की जानकारी दिखती है जिन्हें ऐप्लिकेशन, उपयोगकर्ता के क्रेडेंशियल की मदद से ऐक्सेस करने की अनुमति मांग रहा है. साथ ही, इसमें ऐक्सेस के दायरे की खास जानकारी भी दिखती है. इसके बाद, उपयोगकर्ता आपके ऐप्लिकेशन के अनुरोध किए गए एक या एक से ज़्यादा स्कोप का ऐक्सेस देने की सहमति दे सकता है या अनुरोध को अस्वीकार कर सकता है.

इस चरण में, आपके ऐप्लिकेशन को कुछ करने की ज़रूरत नहीं है. इस दौरान, वह Google के OAuth 2.0 सर्वर से जवाब का इंतज़ार करता है. इससे यह पता चलता है कि ऐप्लिकेशन को ऐक्सेस दिया गया है या नहीं. इस जवाब के बारे में अगले चरण में बताया गया है.

गड़बड़ियां

Google के OAuth 2.0 अनुमति एंडपॉइंट के अनुरोधों से, पुष्टि करने और अनुमति देने के अनुमानित फ़्लो के बजाय, उपयोगकर्ता को गड़बड़ी के मैसेज दिख सकते हैं. गड़बड़ी के सामान्य कोड और सुझाए गए समाधान यहां दिए गए हैं.

admin_policy_enforced

Google खाता, अनुरोध किए गए एक या उससे ज़्यादा स्कोप को अनुमति नहीं दे पा रहा है. ऐसा, Google Workspace एडमिन की नीतियों की वजह से हो रहा है. Google Workspace एडमिन के सहायता लेख यह कंट्रोल करना कि तीसरे पक्ष और आपके डोमेन के मालिकाना हक वाले किन ऐप्लिकेशन से, Google Workspace का डेटा ऐक्सेस किया जा सकता है पर जाएं. यहां आपको इस बारे में ज़्यादा जानकारी मिलेगी कि एडमिन, सभी स्कोप या संवेदनशील और पाबंदी वाले स्कोप के ऐक्सेस पर पाबंदी कैसे लगा सकता है. ऐसा तब तक किया जा सकता है, जब तक आपके OAuth क्लाइंट आईडी को साफ़ तौर पर ऐक्सेस की अनुमति नहीं दी जाती.

disallowed_useragent

ऑथराइज़ेशन एंडपॉइंट, एम्बेड किए गए ऐसे उपयोगकर्ता-एजेंट में दिखता है जिसे Google की OAuth 2.0 नीतियों के तहत अनुमति नहीं है.

Android

Android डेवलपर को अनुमति के अनुरोधों को खोलने पर, android.webkit.WebView में यह गड़बड़ी का मैसेज दिख सकता है. इसके बजाय, डेवलपर को Android लाइब्रेरी का इस्तेमाल करना चाहिए. जैसे, Android के लिए Google साइन इन या OpenID फ़ाउंडेशन की Android के लिए AppAuth.

वेब डेवलपर को यह गड़बड़ी तब दिख सकती है, जब कोई Android ऐप्लिकेशन एम्बेड किए गए उपयोगकर्ता-एजेंट में कोई सामान्य वेब लिंक खोले और कोई उपयोगकर्ता आपकी साइट से, Google के OAuth 2.0 ऑथराइज़ेशन एंडपॉइंट पर जाए. डेवलपर को सामान्य लिंक को ऑपरेटिंग सिस्टम के डिफ़ॉल्ट लिंक हैंडलर में खोलने की अनुमति देनी चाहिए. इसमें Android ऐप्लिकेशन लिंक हैंडलर या डिफ़ॉल्ट ब्राउज़र ऐप्लिकेशन, दोनों शामिल हैं. Android कस्टम टैब लाइब्रेरी भी एक विकल्प है.

iOS

iOS और macOS डेवलपर को अनुमति के अनुरोधों को खोलने पर, यह गड़बड़ी दिख सकती है WKWebView. इसके बजाय, डेवलपर को iOS लाइब्रेरी का इस्तेमाल करना चाहिए. जैसे, iOS के लिए Google साइन इन या OpenID फ़ाउंडेशन की iOS के लिए AppAuth.

वेब डेवलपर को यह गड़बड़ी तब दिख सकती है, जब कोई iOS या macOS ऐप्लिकेशन, एम्बेड किए गए उपयोगकर्ता-एजेंट में कोई सामान्य वेब लिंक खोले और कोई उपयोगकर्ता आपकी साइट से, Google के OAuth 2.0 ऑथराइज़ेशन एंडपॉइंट पर जाए. डेवलपर को सामान्य लिंक को ऑपरेटिंग सिस्टम के डिफ़ॉल्ट लिंक हैंडलर में खोलने की अनुमति देनी चाहिए. इसमें यूनिवर्सल लिंक हैंडलर या डिफ़ॉल्ट ब्राउज़र ऐप्लिकेशन, दोनों शामिल हैं. साथ ही, SFSafariViewController लाइब्रेरी भी एक विकल्प है.
org_internal

अनुरोध में दिया गया OAuth क्लाइंट आईडी, किसी ऐसे प्रोजेक्ट का हिस्सा है जो किसी खास Google Cloud संगठन में Google खातों के ऐक्सेस को सीमित करता है. इस कॉन्फ़िगरेशन के विकल्प के बारे में ज़्यादा जानने के लिए, OAuth की सहमति वाली स्क्रीन सेट अप करने के बारे में सहायता लेख में, उपयोगकर्ता टाइप सेक्शन देखें.

invalid_client

OAuth क्लाइंट सीक्रेट गलत है. OAuth क्लाइंट कॉन्फ़िगरेशन की समीक्षा करें. इसमें, इस अनुरोध के लिए इस्तेमाल किए गए क्लाइंट आईडी और सीक्रेट की जानकारी भी शामिल है.

invalid_grant

ऐक्सेस टोकन को रीफ़्रेश करते समय या इंक्रीमेंटल अनुमति का इस्तेमाल करते समय, हो सकता है कि टोकन की समयसीमा खत्म हो गई हो या उसे अमान्य कर दिया गया हो. उपयोगकर्ता की फिर से पुष्टि करें और नए टोकन पाने के लिए, उपयोगकर्ता की सहमति लें. अगर आपको यह गड़बड़ी दिखती रहती है, तो पक्का करें कि आपका ऐप्लिकेशन सही तरीके से कॉन्फ़िगर किया गया हो और आपने अनुरोध में सही टोकन और पैरामीटर का इस्तेमाल किया हो. ऐसा न होने पर, हो सकता है कि उपयोगकर्ता का खाता मिटा दिया गया हो या बंद कर दिया गया हो.

redirect_uri_mismatch

अनुमति के अनुरोध में दिया गया redirect_uri, OAuth क्लाइंट आईडी के लिए अनुमति वाले रीडायरेक्ट यूआरआई से मेल नहीं खाता. Google API Console Credentials pageमें जाकर, अनुमति वाले रीडायरेक्ट यूआरआई की समीक्षा करें.

redirect_uri पैरामीटर, OAuth के ऐसे फ़्लो का रेफ़रंस दे सकता है जो अब काम नहीं करता. अपने इंटिग्रेशन को अपडेट करने के लिए, माइग्रेशन गाइड देखें.

invalid_request

आपके अनुरोध में कोई गड़बड़ी थी. ऐसा कई वजहों से हो सकता है:

  • अनुरोध को सही तरीके से फ़ॉर्मैट नहीं किया गया था
  • अनुरोध में ज़रूरी पैरामीटर मौजूद नहीं थे
  • अनुरोध में, अनुमति देने के लिए किसी ऐसे तरीके का इस्तेमाल किया गया है जिसकी अनुमति Google नहीं देता. पुष्टि करें कि आपके OAuth इंटिग्रेशन में, इंटिग्रेशन के लिए सुझाए गए तरीके का इस्तेमाल किया गया है

चौथा चरण: OAuth 2.0 सर्वर के जवाब को मैनेज करना

OAuth 2.0 सर्वर, अनुरोध में बताए गए यूआरएल का इस्तेमाल करके, आपके ऐप्लिकेशन के ऐक्सेस अनुरोध का जवाब देता है.

अगर उपयोगकर्ता, ऐक्सेस के अनुरोध को स्वीकार कर लेता है, तो रिस्पॉन्स में ऑथराइज़ेशन कोड शामिल होता है. अगर उपयोगकर्ता अनुरोध को स्वीकार नहीं करता है, तो जवाब में गड़बड़ी का मैसेज दिखता है. वेब सर्वर को मिले अनुमति कोड या गड़बड़ी के मैसेज को क्वेरी स्ट्रिंग पर दिखाया जाता है, जैसा कि यहां दिखाया गया है:

गड़बड़ी का जवाब:

https://oauth2.example.com/auth?error=access_denied

ऑथराइज़ेशन कोड का रिस्पॉन्स:

https://oauth2.example.com/auth?code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7

OAuth 2.0 सर्वर रिस्पॉन्स का सैंपल

इस फ़्लो की जांच करने के लिए, यहां दिए गए सैंपल यूआरएल पर क्लिक करें. यह यूआरएल, आपके Google Drive में मौजूद फ़ाइलों का मेटाडेटा देखने के लिए, सिर्फ़ पढ़ने का ऐक्सेस और Google Calendar के इवेंट देखने के लिए, सिर्फ़ पढ़ने का ऐक्सेस मांगता है: 

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

OAuth 2.0 फ़्लो पूरा करने के बाद, आपको http://localhost/oauth2callback पर रीडायरेक्ट किया जाएगा. ऐसा होने पर, आपको 404 NOT FOUND गड़बड़ी का मैसेज दिख सकता है. हालांकि, ऐसा तब तक नहीं होगा, जब तक आपकी लोकल मशीन उस पते पर कोई फ़ाइल नहीं दिखाती. अगले चरण में, उपयोगकर्ता को आपके ऐप्लिकेशन पर वापस रीडायरेक्ट करने पर, यूआरआई में दी गई जानकारी के बारे में ज़्यादा जानकारी मिलती है.

पांचवां चरण: रीफ़्रेश और ऐक्सेस टोकन के लिए ऑथराइज़ेशन कोड बदलना

वेब सर्वर को ऑथराइज़ेशन कोड मिलने के बाद, वह ऑथराइज़ेशन कोड को ऐक्सेस टोकन से बदल सकता है.

PHP

ऑथराइज़ेशन कोड को ऐक्सेस टोकन में बदलने के लिए, fetchAccessTokenWithAuthCode तरीके का इस्तेमाल करें:

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

Python

अपने कॉलबैक पेज पर, अनुमति देने वाले सर्वर के जवाब की पुष्टि करने के लिए, 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}

Ruby

अपने कॉलबैक पेज पर, अनुमति देने वाले सर्वर के रिस्पॉन्स की पुष्टि करने के लिए, googleauth लाइब्रेरी का इस्तेमाल करें. ऑथराइज़ेशन कोड को सेव करने के लिए, authorizer.handle_auth_callback_deferred तरीके का इस्तेमाल करें. इसके बाद, उस यूआरएल पर रीडायरेक्ट करें जिस पर मूल रूप से अनुमति का अनुरोध किया गया था. इससे, उपयोगकर्ता के सेशन में नतीजों को कुछ समय के लिए सेव करके, कोड के एक्सचेंज को कुछ समय के लिए रोक दिया जाता है.

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

Node.js

ऑथराइज़ेशन कोड को ऐक्सेस टोकन में बदलने के लिए, 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);
});

एचटीटीपी/REST

ऑथराइज़ेशन कोड को ऐक्सेस टोकन से बदलने के लिए, https://oauth2.googleapis.com/token एंडपॉइंट को कॉल करें और ये पैरामीटर सेट करें:

फ़ील्ड
client_id API Console Credentials pageसे मिला क्लाइंट आईडी.
client_secret API Console Credentials pageसे मिला क्लाइंट सीक्रेट.
code शुरुआती अनुरोध से मिला ऑथराइज़ेशन कोड.
grant_type OAuth 2.0 के स्पेसिफ़िकेशन में बताए गए मुताबिक, इस फ़ील्ड की वैल्यू authorization_code पर सेट होनी चाहिए.
redirect_uri दिए गए client_id के लिए, API Console Credentials page में आपके प्रोजेक्ट के लिए सूची में शामिल रीडायरेक्ट यूआरआई में से एक.

यहां दिया गया स्निपेट, अनुरोध का सैंपल दिखाता है:

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

Google इस अनुरोध का जवाब, एक JSON ऑब्जेक्ट के तौर पर देता है. इसमें कुछ समय के लिए मान्य ऐक्सेस टोकन और रीफ़्रेश टोकन होता है. ध्यान दें कि रीफ़्रेश टोकन सिर्फ़ तब दिखाया जाता है, जब आपका ऐप्लिकेशन Google के अनुमति देने वाले सर्वर को किए गए शुरुआती अनुरोध में, access_type पैरामीटर को offline पर सेट करता है.

रिस्पॉन्स में ये फ़ील्ड शामिल होते हैं:

फ़ील्ड
access_token यह वह टोकन होता है जिसे आपका ऐप्लिकेशन, Google API के अनुरोध को अनुमति देने के लिए भेजता है.
expires_in ऐक्सेस टोकन के बचे हुए लाइफ़टाइम की जानकारी, सेकंड में.
refresh_token ऐसा टोकन जिसका इस्तेमाल करके नया ऐक्सेस टोकन हासिल किया जा सकता है. रीफ़्रेश टोकन तब तक मान्य रहते हैं, जब तक उपयोगकर्ता ऐक्सेस रद्द नहीं कर देता. फिर से, यह फ़ील्ड इस रिस्पॉन्स में सिर्फ़ तब मौजूद होता है, जब Google के अनुमति देने वाले सर्वर को किए गए शुरुआती अनुरोध में, access_type पैरामीटर को offline पर सेट किया जाता है.
scope access_token से मिले ऐक्सेस के दायरे, स्पेस से अलग की गई, केस-सेंसिटिव स्ट्रिंग की सूची के तौर पर दिखाए जाते हैं.
token_type दिखाया गया टोकन टाइप. फ़िलहाल, इस फ़ील्ड की वैल्यू हमेशा Bearer पर सेट होती है.

यहां दिया गया स्निपेट, जवाब का एक सैंपल दिखाता है:

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

गड़बड़ियां

ऑथराइज़ेशन कोड को ऐक्सेस टोकन में बदलते समय, आपको उम्मीद के मुताबिक रिस्पॉन्स के बजाय यह गड़बड़ी दिख सकती है. गड़बड़ी के सामान्य कोड और सुझाए गए समाधान यहां दिए गए हैं.

invalid_grant

दिया गया ऑथराइज़ेशन कोड अमान्य है या गलत फ़ॉर्मैट में है. उपयोगकर्ता से फिर से सहमति पाने के लिए, OAuth प्रोसेस को फिर से शुरू करके नए कोड का अनुरोध करें.

छठा चरण: देखें कि उपयोगकर्ताओं ने कौनसे स्कोप दिए हैं

एक बार में कई स्कोप का अनुरोध करने पर, हो सकता है कि उपयोगकर्ता आपके ऐप्लिकेशन के सभी अनुरोधों को स्वीकार न करें. आपके ऐप्लिकेशन को हमेशा यह देखना चाहिए कि उपयोगकर्ता ने किन स्कोप को अनुमति दी है. साथ ही, ज़रूरी सुविधाओं को बंद करके, स्कोप के अस्वीकार होने की स्थिति को मैनेज करना चाहिए. ज़्यादा जानकारी के लिए, ज़्यादा जानकारी वाली अनुमतियों को मैनेज करने का तरीका लेख पढ़ें.

PHP

यह देखने के लिए कि उपयोगकर्ता ने कौनसे स्कोप दिए हैं, getGrantedScope() तरीके का इस्तेमाल करें:

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

Python

दिखाए गए 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}

Ruby

एक साथ कई स्कोप का अनुरोध करते समय, देखें कि 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

Node.js

एक साथ कई स्कोप का अनुरोध करते समय, देखें कि 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
}

एचटीटीपी/REST

यह देखने के लिए कि उपयोगकर्ता ने आपके ऐप्लिकेशन को किसी खास स्कोप का ऐक्सेस दिया है या नहीं, ऐक्सेस टोकन के जवाब में 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 को कॉल करना

PHP

Google API को कॉल करने के लिए, ऐक्सेस टोकन का इस्तेमाल करें. इसके लिए, यह तरीका अपनाएं:

  1. अगर आपको किसी नए Google\Client ऑब्जेक्ट पर ऐक्सेस टोकन लागू करना है, तो setAccessToken तरीके का इस्तेमाल करें. उदाहरण के लिए, अगर आपने ऐक्सेस टोकन को उपयोगकर्ता सेशन में सेव किया है, तो: 
    $client->setAccessToken($access_token);
  2. आपको जिस एपीआई को कॉल करना है उसके लिए सेवा ऑब्जेक्ट बनाएं. आपको जिस एपीआई को कॉल करना है उसके लिए, अनुमति वाला Google\Client ऑब्जेक्ट उपलब्ध कराकर, सेवा ऑब्जेक्ट बनाया जाता है. उदाहरण के लिए, YouTube Data API को कॉल करने के लिए: 
    $youtube = new Google_Service_YouTube($client);
  3. सेवा ऑब्जेक्ट से मिले इंटरफ़ेस का इस्तेमाल करके, एपीआई सेवा के लिए अनुरोध करें. उदाहरण के लिए, अनुमति वाले उपयोगकर्ता के YouTube चैनल का डेटा पाने के लिए: 
    $channel = $youtube->channels->listChannels('snippet', array('mine' => $mine));

Python

ऐक्सेस टोकन मिलने के बाद, आपका ऐप्लिकेशन उस टोकन का इस्तेमाल करके, किसी उपयोगकर्ता खाते या सेवा खाते की ओर से एपीआई अनुरोधों को अनुमति दे सकता है. आपको जिस एपीआई को कॉल करना है उसके लिए सेवा ऑब्जेक्ट बनाने के लिए, उपयोगकर्ता के हिसाब से अनुमति देने वाले क्रेडेंशियल का इस्तेमाल करें. इसके बाद, अनुमति वाले एपीआई अनुरोध करने के लिए उस ऑब्जेक्ट का इस्तेमाल करें.

  1. आपको जिस एपीआई को कॉल करना है उसके लिए सेवा ऑब्जेक्ट बनाएं. सेवा ऑब्जेक्ट बनाने के लिए, एपीआई के नाम और वर्शन के साथ-साथ उपयोगकर्ता के क्रेडेंशियल का इस्तेमाल करके, googleapiclient.discovery लाइब्रेरी के build तरीके को कॉल करें: उदाहरण के लिए, YouTube Data API के वर्शन 3 को कॉल करने के लिए: 
    from googleapiclient.discovery import build

youtube = build('youtube', 'v3', credentials=credentials)
  2. सेवा ऑब्जेक्ट से मिले इंटरफ़ेस का इस्तेमाल करके, एपीआई सेवा के लिए अनुरोध करें. उदाहरण के लिए, अनुमति वाले उपयोगकर्ता के YouTube चैनल का डेटा पाने के लिए: 
    channel = youtube.channels().list(mine=True, part='snippet').execute()

Ruby

ऐक्सेस टोकन मिलने के बाद, आपका ऐप्लिकेशन उस टोकन का इस्तेमाल करके, किसी उपयोगकर्ता खाते या सेवा खाते की ओर से एपीआई अनुरोध कर सकता है. आपको जिस एपीआई को कॉल करना है उसके लिए सेवा ऑब्जेक्ट बनाने के लिए, उपयोगकर्ता के हिसाब से अनुमति देने वाले क्रेडेंशियल का इस्तेमाल करें. इसके बाद, अनुमति वाले एपीआई अनुरोध करने के लिए उस ऑब्जेक्ट का इस्तेमाल करें.

  1. आपको जिस एपीआई को कॉल करना है उसके लिए सेवा ऑब्जेक्ट बनाएं. उदाहरण के लिए, YouTube Data API के वर्शन 3 को कॉल करने के लिए: 
    youtube = Google::Apis::YoutubeV3::YouTubeService.new
  2. सेवा पर क्रेडेंशियल सेट करें: 
    youtube.authorization = credentials
  3. सेवा ऑब्जेक्ट से मिले इंटरफ़ेस का इस्तेमाल करके, एपीआई सेवा के लिए अनुरोध करें. उदाहरण के लिए, अनुमति वाले उपयोगकर्ता के YouTube चैनल का डेटा पाने के लिए: 
    channel = youtube.list_channels(part, :mine => mine)

इसके अलावा, अनुमति को हर तरीके के हिसाब से दिया जा सकता है. इसके लिए, किसी तरीके के लिए options पैरामीटर दें:

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

Node.js

ऐक्सेस टोकन पाने और उसे OAuth2 ऑब्जेक्ट पर सेट करने के बाद, Google के एपीआई को कॉल करने के लिए ऑब्जेक्ट का इस्तेमाल करें. आपका ऐप्लिकेशन, किसी उपयोगकर्ता खाते या सेवा खाते की ओर से एपीआई अनुरोधों को अनुमति देने के लिए, उस टोकन का इस्तेमाल कर सकता है. आपको जिस एपीआई को कॉल करना है उसके लिए सेवा ऑब्जेक्ट बनाएं. उदाहरण के लिए, नीचे दिया गया कोड, उपयोगकर्ता के Drive में फ़ाइलों के नामों की सूची बनाने के लिए, 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);
  }
});

एचटीटीपी/REST

जब आपके ऐप्लिकेशन को ऐक्सेस टोकन मिल जाता है, तो किसी उपयोगकर्ता खाते की ओर से Google API को कॉल करने के लिए, टोकन का इस्तेमाल किया जा सकता है. हालांकि, इसके लिए ज़रूरी है कि एपीआई को ऐक्सेस का ज़रूरी दायरा दिया गया हो. ऐसा करने के लिए, एपीआई के अनुरोध में ऐक्सेस टोकन शामिल करें. इसके लिए, access_token क्वेरी पैरामीटर या Authorization एचटीटीपी हेडर Bearer की वैल्यू शामिल करें. जब भी हो सके, एचटीटीपी हेडर का इस्तेमाल करें. ऐसा इसलिए, क्योंकि क्वेरी स्ट्रिंग, सर्वर लॉग में दिखती हैं. ज़्यादातर मामलों में, Google API के कॉल सेट अप करने के लिए, क्लाइंट लाइब्रेरी का इस्तेमाल किया जा सकता है. उदाहरण के लिए, YouTube Data API को कॉल करते समय.

ध्यान दें कि YouTube Data API, सिर्फ़ उन YouTube कॉन्टेंट के मालिकों के लिए सेवा खातों के साथ काम करता है जिनके पास एक से ज़्यादा YouTube चैनलों का मालिकाना हक होता है और जिन्हें वे मैनेज करते हैं. जैसे, रिकॉर्ड लेबल और फ़िल्म स्टूडियो.

OAuth 2.0 Playground पर जाकर, Google के सभी एपीआई आज़माए जा सकते हैं और उनके दायरे देखे जा सकते हैं.

एचटीटीपी GET के उदाहरण

Authorization: Bearer एचटीटीपी हेडर का इस्तेमाल करके, 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 क्वेरी स्ट्रिंग पैरामीटर का इस्तेमाल करके, उसी एपीआई को कॉल किया गया है:

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

curl के उदाहरण

इन कमांड की जांच, curl कमांड-लाइन ऐप्लिकेशन की मदद से की जा सकती है. यहां एक उदाहरण दिया गया है, जिसमें एचटीटीपी हेडर के विकल्प का इस्तेमाल किया गया है. यह विकल्प इस्तेमाल करना सबसे सही है:

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

पूरा उदाहरण

यहां दिए गए उदाहरण में, JSON फ़ॉर्मैट में एक ऑब्जेक्ट को प्रिंट किया गया है. इसमें, उपयोगकर्ता के YouTube चैनल की जानकारी दिख रही है. यह जानकारी, उपयोगकर्ता के YouTube खाते को मैनेज करने के लिए, ऐप्लिकेशन की पुष्टि करने और उसे अनुमति देने के बाद दिखती है.

PHP

यह उदाहरण चलाने के लिए:

  1. API Consoleमें, रीडायरेक्ट यूआरएल की सूची में लोकल मशीन का यूआरएल जोड़ें. उदाहरण के लिए, http://localhost:8080 जोड़ें.
  2. नई डायरेक्ट्री बनाएं और उस पर स्विच करें. उदाहरण के लिए: 
    mkdir ~/php-oauth2-example
cd ~/php-oauth2-example
  3. Composer का इस्तेमाल करके, PHP के लिए Google API क्लाइंट लाइब्रेरी इंस्टॉल करें: 
    composer require google/apiclient:^2.15.0
  4. यहां दिए गए कॉन्टेंट के साथ index.php और oauth2callback.php फ़ाइलें बनाएं.
  5. 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_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));
}
?>

oauth2callback.php

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

Python

इस उदाहरण में, Flask फ़्रेमवर्क का इस्तेमाल किया गया है. यह http://localhost:8080 पर एक वेब ऐप्लिकेशन चलाता है, जिससे OAuth 2.0 फ़्लो की जांच की जा सकती है. उस यूआरएल पर जाने पर, आपको पांच लिंक दिखेंगे:

  • एपीआई अनुरोध की जांच करना: यह लिंक ऐसे पेज पर ले जाता है जो एपीआई के सैंपल अनुरोध को लागू करने की कोशिश करता है. अगर ज़रूरी हो, तो यह अनुमति फ़्लो शुरू करता है. अगर अनुरोध पूरा हो जाता है, तो पेज पर एपीआई का जवाब दिखता है.
  • पुष्टि करने के फ़्लो की सीधे तौर पर जांच करना: यह लिंक, उपयोगकर्ता को पुष्टि करने के फ़्लो पर भेजने की कोशिश करता है. ऐप्लिकेशन, उपयोगकर्ता की ओर से अनुमति वाले एपीआई अनुरोध सबमिट करने के लिए अनुमति का अनुरोध करता है.
  • मौजूदा क्रेडेंशियल रद्द करें: यह लिंक, उस पेज पर ले जाता है जो उपयोगकर्ता के ऐप्लिकेशन को पहले से दी गई अनुमतियों को रद्द करता है.
  • Flask सेशन के क्रेडेंशियल मिटाएं: यह लिंक, Flask सेशन में सेव किए गए अनुमति क्रेडेंशियल मिटा देता है. इससे आपको यह देखने में मदद मिलती है कि अगर कोई उपयोगकर्ता, जो पहले से ही आपके ऐप्लिकेशन को अनुमति दे चुका है, तो नए सेशन में एपीआई अनुरोध करने की कोशिश करता है, तो क्या होगा. इससे आपको यह भी पता चलता है कि अगर उपयोगकर्ता ने आपके ऐप्लिकेशन को दी गई अनुमतियां रद्द कर दी हैं और आपके ऐप्लिकेशन ने फिर भी रद्द किए गए ऐक्सेस टोकन की मदद से अनुरोध को अनुमति देने की कोशिश की है, तो आपके ऐप्लिकेशन को एपीआई से क्या जवाब मिलेगा.
# -*- 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"

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

Ruby

इस उदाहरण में, 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)
end

get '/' 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

Node.js

यह उदाहरण चलाने के लिए:

  1. API Consoleमें, रीडायरेक्ट यूआरएल की सूची में लोकल मशीन का यूआरएल जोड़ें. उदाहरण के लिए, http://localhost जोड़ें.
  2. पक्का करें कि आपने Node.js का रखरखाव वाला LTS, चालू LTS या मौजूदा रिलीज़ इंस्टॉल किया हो.
  3. नई डायरेक्ट्री बनाएं और उस पर स्विच करें. उदाहरण के लिए: 
    mkdir ~/nodejs-oauth2-example
cd ~/nodejs-oauth2-example
  4. npm का इस्तेमाल करके, Node.js के लिए Google API क्लाइंट लाइब्रेरी इंस्टॉल करें: 
    npm install googleapis
  5. यहां दिए गए कॉन्टेंट के साथ main.js फ़ाइलें बनाएं.
  6. उदाहरण चलाएं: 
    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 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);

एचटीटीपी/REST

इस Python उदाहरण में, OAuth 2.0 वेब फ़्लो को दिखाने के लिए, Flask फ़्रेमवर्क और Requests लाइब्रेरी का इस्तेमाल किया गया है. हमारा सुझाव है कि इस फ़्लो के लिए, Python के लिए Google API क्लाइंट लाइब्रेरी का इस्तेमाल करें. (Python टैब में दिए गए उदाहरण में क्लाइंट लाइब्रेरी का इस्तेमाल किया गया है.)

import json
import flask
import requests

app = 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()

रीडायरेक्ट यूआरआई की पुष्टि करने के नियम

Google, रीडायरेक्ट यूआरआई पर पुष्टि करने के लिए ये नियम लागू करता है, ताकि डेवलपर अपने ऐप्लिकेशन को सुरक्षित रख सकें. आपके रीडायरेक्ट यूआरआई को इन नियमों का पालन करना होगा. डोमेन, होस्ट, पाथ, क्वेरी, स्कीम, और उपयोगकर्ता जानकारी की परिभाषा के लिए, यहां दिए गए आरएफ़सी 3986 सेक्शन 3 देखें.

सत्यापन नियम
स्कीम

रीडायरेक्ट यूआरआई के लिए, एचटीटीपीएस स्कीम का इस्तेमाल किया जाना चाहिए, न कि एचटीटीपी का. localhost यूआरआई (इसमें localhost आईपी पते के यूआरआई भी शामिल हैं) पर यह नियम लागू नहीं होता.
होस्ट

होस्ट के तौर पर रॉ आईपी पते इस्तेमाल नहीं किए जा सकते. localhost आईपी पतों पर यह नियम लागू नहीं होता.
डोमेन
  • होस्ट के टीएलडी (टॉप लेवल डोमेन), सार्वजनिक सफ़िक्स सूची में शामिल होने चाहिए.
  • होस्ट डोमेन “googleusercontent.com” नहीं हो सकते.
  • रीडायरेक्ट यूआरआई में, यूआरएल छोटा करने वाले डोमेन (जैसे, goo.gl) शामिल नहीं किए जा सकते. ऐसा तब तक नहीं किया जा सकता, जब तक कि ऐप्लिकेशन के पास डोमेन का मालिकाना हक न हो. इसके अलावा, अगर किसी ऐप्लिकेशन के पास छोटा करने वाले डोमेन का मालिकाना हक है और वह उस डोमेन पर रीडायरेक्ट करना चाहता है, तो रीडायरेक्ट यूआरआई के पाथ में “/google-callback/” होना चाहिए या वह “/google-callback” पर खत्म होना चाहिए.
    		•
    Userinfo

    रीडायरेक्ट यूआरआई में userinfo सब-कॉम्पोनेंट शामिल नहीं किया जा सकता.
    पाथ

    रीडायरेक्ट यूआरआई में पाथ ट्रेवर्सल (इसे डायरेक्ट्री बैकट्रैकिंग भी कहा जाता है) नहीं हो सकता. इसे “/..” या “\..” या उनके यूआरएल कोड में बदलकर दिखाया जाता है.
    क्वेरी

    रीडायरेक्ट यूआरआई में, ओपन रीडायरेक्ट शामिल नहीं होने चाहिए.
    फ़्रैगमेंट

    रीडायरेक्ट यूआरआई में फ़्रैगमेंट कॉम्पोनेंट नहीं हो सकता.
    वर्ण रीडायरेक्ट यूआरआई में कुछ वर्ण शामिल नहीं किए जा सकते. इनमें ये वर्ण शामिल हैं:
    • वाइल्डकार्ड वर्ण ('*')
    • प्रिंट न किए जा सकने वाले ASCII वर्ण
    • प्रतिशत को कोड में बदलने का अमान्य तरीका (कोई भी प्रतिशत कोड, जो यूआरएल को कोड में बदलने के तरीके के मुताबिक न हो. जैसे, प्रतिशत के चिह्न के बाद दो हेक्साडेसिमल अंक)
    • शून्य वर्ण (एन्कोड किया गया शून्य वर्ण, जैसे कि %00, %C0%80)

    इंक्रीमेंटल अनुमति

    OAuth 2.0 प्रोटोकॉल में, आपका ऐप्लिकेशन उन संसाधनों को ऐक्सेस करने के लिए अनुमति का अनुरोध करता है जिन्हें स्कोप से पहचाना जाता है. उपयोगकर्ता अनुभव के लिहाज़ से, संसाधनों के लिए अनुमति का अनुरोध तब करना सबसे सही माना जाता है, जब आपको उनकी ज़रूरत हो. इस प्रोसेस को चालू करने के लिए, Google का अनुमति देने वाला सर्वर, धीरे-धीरे अनुमति देने की सुविधा के साथ काम करता है. इस सुविधा की मदद से, ज़रूरत के हिसाब से स्कोप का अनुरोध किया जा सकता है. अगर उपयोगकर्ता नए स्कोप के लिए अनुमति देता है, तो अनुमति देने वाला कोड दिखाया जाता है. इस कोड को ऐसे टोकन से बदला जा सकता है जिसमें वे सभी स्कोप शामिल होते हैं जिन्हें उपयोगकर्ता ने प्रोजेक्ट को दिया है.

    उदाहरण के लिए, मान लें कि कोई ऐप्लिकेशन लोगों को आस-पास होने वाले दिलचस्प इवेंट की जानकारी देता है. इस ऐप्लिकेशन की मदद से, उपयोगकर्ता इवेंट के बारे में वीडियो देख सकते हैं, वीडियो को रेटिंग दे सकते हैं, और उन्हें प्लेलिस्ट में जोड़ सकते हैं. उपयोगकर्ता इस ऐप्लिकेशन का इस्तेमाल करके, अपने Google Calendar में इवेंट भी जोड़ सकते हैं.

    ऐसे में, हो सकता है कि साइन इन के समय, ऐप्लिकेशन को किसी स्कोप का ऐक्सेस न चाहिए हो या वह उसका अनुरोध न करता हो. हालांकि, अगर उपयोगकर्ता ने किसी वीडियो को रेटिंग देने, प्लेलिस्ट में वीडियो जोड़ने या YouTube पर कोई दूसरी कार्रवाई करने की कोशिश की, तो ऐप्लिकेशन https://www.googleapis.com/auth/youtube.force-ssl स्कोप को ऐक्सेस करने का अनुरोध कर सकता है. इसी तरह, अगर उपयोगकर्ता ने कैलेंडर इवेंट जोड़ने की कोशिश की, तो ऐप्लिकेशन https://www.googleapis.com/auth/calendar स्कोप के ऐक्सेस का अनुरोध कर सकता है.

    ज़्यादा अनुमति देने की सुविधा लागू करने के लिए, ऐक्सेस टोकन का अनुरोध करने का सामान्य फ़्लो पूरा करें. हालांकि, पक्का करें कि अनुमति के अनुरोध में पहले से दिए गए स्कोप शामिल हों. इस तरीके से, आपके ऐप्लिकेशन को एक से ज़्यादा ऐक्सेस टोकन मैनेज करने की ज़रूरत नहीं पड़ती.

    इनक्रीमेंटल अनुमति से मिले ऐक्सेस टोकन पर ये नियम लागू होते हैं:

    • टोकन का इस्तेमाल, नए और एक साथ दिए गए अनुमति वाले किसी भी स्कोप से जुड़े संसाधनों को ऐक्सेस करने के लिए किया जा सकता है.
    • ऐक्सेस टोकन पाने के लिए, एक साथ कई अनुमतियों के लिए रीफ़्रेश टोकन का इस्तेमाल करने पर, ऐक्सेस टोकन एक साथ कई अनुमतियों को दिखाता है. साथ ही, इसका इस्तेमाल रिस्पॉन्स में शामिल किसी भी scope वैल्यू के लिए किया जा सकता है.
    • एक साथ दी गई अनुमति में वे सभी स्कोप शामिल होते हैं जिन्हें उपयोगकर्ता ने एपीआई प्रोजेक्ट को दिया है. भले ही, अनुमतियों का अनुरोध अलग-अलग क्लाइंट से किया गया हो. उदाहरण के लिए, अगर किसी उपयोगकर्ता ने ऐप्लिकेशन के डेस्कटॉप क्लाइंट का इस्तेमाल करके एक स्कोप का ऐक्सेस दिया और फिर मोबाइल क्लाइंट के ज़रिए उसी ऐप्लिकेशन को दूसरा स्कोप दिया, तो अनुमति देने की प्रोसेस में दोनों स्कोप शामिल होंगे.
    • अगर किसी ऐसे टोकन को रद्द किया जाता है जो कई अनुमतियों को दिखाता है, तो उससे जुड़े उपयोगकर्ता के लिए, अनुमति के सभी स्कोप का ऐक्सेस एक साथ रद्द कर दिया जाता है.

    पहला चरण: अनुमति के पैरामीटर सेट करना में, भाषा के हिसाब से दिए गए कोड के सैंपल और दूसरा चरण: Google के OAuth 2.0 सर्वर पर रीडायरेक्ट करना में, एचटीटीपी/REST रीडायरेक्ट यूआरएल के सैंपल में, सभी इंक्रीमेंटल अनुमति का इस्तेमाल करते हैं. नीचे दिए गए कोड सैंपल में, वह कोड भी दिखता है जिसे इंक्रीमेंटल ऑथराइज़ेशन का इस्तेमाल करने के लिए जोड़ना होगा.

    PHP

    $client->setIncludeGrantedScopes(true);

    Python

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

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

    एचटीटीपी/REST

    इस उदाहरण में, कॉल करने वाला ऐप्लिकेशन, उपयोगकर्ता के YouTube Analytics डेटा को ऐक्सेस करने का अनुरोध करता है. साथ ही, वह ऐक्सेस के लिए उन सभी अनुमतियों का भी अनुरोध करता है जिन्हें उपयोगकर्ता ने पहले ही ऐप्लिकेशन को दिया है.

    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

    Refreshing an access token (offline access)

    Access tokens periodically expire and become invalid credentials for a related API request. You can refresh an access token without prompting the user for permission (including when the user is not present) if you requested offline access to the scopes associated with the token.

    • If you use a Google API Client Library, the client object refreshes the access token as needed as long as you configure that object for offline access.
    • If you are not using a client library, you need to set the access_type HTTP query parameter to offline when redirecting the user to Google's OAuth 2.0 server. In that case, Google's authorization server returns a refresh token when you exchange an authorization code for an access token. Then, if the access token expires (or at any other time), you can use a refresh token to obtain a new access token.

    Requesting offline access is a requirement for any application that needs to access a Google API when the user is not present. For example, an app that performs backup services or executes actions at predetermined times needs to be able to refresh its access token when the user is not present. The default style of access is called online.

    Server-side web applications, installed applications, and devices all obtain refresh tokens during the authorization process. Refresh tokens are not typically used in client-side (JavaScript) web applications.

    PHP

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

    $client->setAccessType("offline");

    जब कोई उपयोगकर्ता, अनुरोध किए गए स्कोप के लिए ऑफ़लाइन ऐक्सेस की अनुमति देता है, तो उपयोगकर्ता के ऑफ़लाइन होने पर, उसकी ओर से Google API को ऐक्सेस करने के लिए, एपीआई क्लाइंट का इस्तेमाल जारी रखा जा सकता है. क्लाइंट ऑब्जेक्ट, ज़रूरत के हिसाब से ऐक्सेस टोकन को रीफ़्रेश करेगा.

    Python

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

    जब कोई उपयोगकर्ता, अनुरोध किए गए स्कोप के लिए ऑफ़लाइन ऐक्सेस की अनुमति देता है, तो उपयोगकर्ता के ऑफ़लाइन होने पर, उसकी ओर से Google API को ऐक्सेस करने के लिए, एपीआई क्लाइंट का इस्तेमाल जारी रखा जा सकता है. क्लाइंट ऑब्जेक्ट, ज़रूरत के हिसाब से ऐक्सेस टोकन को रीफ़्रेश करेगा.

    Ruby

    अगर आपके ऐप्लिकेशन को Google API का ऑफ़लाइन ऐक्सेस चाहिए, तो एपीआई क्लाइंट के ऐक्सेस टाइप को offline पर सेट करें:

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

    जब कोई उपयोगकर्ता, अनुरोध किए गए स्कोप के लिए ऑफ़लाइन ऐक्सेस की अनुमति देता है, तो उपयोगकर्ता के ऑफ़लाइन होने पर, उसकी ओर से Google API को ऐक्सेस करने के लिए, एपीआई क्लाइंट का इस्तेमाल जारी रखा जा सकता है. क्लाइंट ऑब्जेक्ट, ज़रूरत के हिसाब से ऐक्सेस टोकन को रीफ़्रेश करेगा.

    Node.js

    अगर आपके ऐप्लिकेशन को Google 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
});

    जब कोई उपयोगकर्ता, अनुरोध किए गए स्कोप के लिए ऑफ़लाइन ऐक्सेस की अनुमति देता है, तो उपयोगकर्ता के ऑफ़लाइन होने पर, उसकी ओर से Google API को ऐक्सेस करने के लिए, एपीआई क्लाइंट का इस्तेमाल जारी रखा जा सकता है. क्लाइंट ऑब्जेक्ट, ज़रूरत के हिसाब से ऐक्सेस टोकन को रीफ़्रेश करेगा.

    ऐक्सेस टोकन की समयसीमा खत्म हो जाती है. अगर ऐक्सेस टोकन की समयसीमा खत्म होने वाली है, तो यह लाइब्रेरी अपने-आप रीफ़्रेश टोकन का इस्तेमाल करके नया ऐक्सेस टोकन हासिल करेगी. टोकन इवेंट का इस्तेमाल करके, यह पक्का किया जा सकता है कि आपके पास हमेशा सबसे नए टोकन हों:

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

    क्लाइंट के पास रीफ़्रेश टोकन होने के बाद, एपीआई के अगले कॉल में ऐक्सेस टोकन अपने-आप हासिल हो जाएंगे और रीफ़्रेश हो जाएंगे.

    एचटीटीपी/REST

    ऐक्सेस टोकन को रीफ़्रेश करने के लिए, आपका ऐप्लिकेशन Google के ऑथराइज़ेशन सर्वर (https://oauth2.googleapis.com/token) को एचटीटीपीएस POST अनुरोध भेजता है. इस अनुरोध में ये पैरामीटर शामिल होते हैं:

    फ़ील्ड
    client_id API Consoleसे मिला क्लाइंट आईडी.
    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-urlencoded

client_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"
}

    ध्यान दें कि जारी किए जाने वाले रीफ़्रेश टोकन की संख्या सीमित होती है. हर क्लाइंट/उपयोगकर्ता के कॉम्बिनेशन के लिए एक सीमा और सभी क्लाइंट के लिए हर उपयोगकर्ता के लिए एक सीमा तय होती है. आपको रीफ़्रेश टोकन को लंबे समय तक स्टोर करने की सुविधा में सेव करना चाहिए. साथ ही, जब तक वे मान्य हैं, तब तक उनका इस्तेमाल करना जारी रखना चाहिए. अगर आपका ऐप्लिकेशन बहुत ज़्यादा रीफ़्रेश टोकन का अनुरोध करता है, तो हो सकता है कि वह इन सीमाओं तक पहुंच जाए. ऐसे में, पुराने रीफ़्रेश टोकन काम करना बंद कर देंगे.

    टोकन रद्द करना

    कुछ मामलों में, हो सकता है कि उपयोगकर्ता किसी ऐप्लिकेशन को दिया गया ऐक्सेस रद्द करना चाहे. उपयोगकर्ता, खाता सेटिंग पर जाकर, ऐक्सेस रद्द कर सकता है. ज़्यादा जानकारी के लिए, तीसरे पक्ष की ऐसी साइटों और ऐप्लिकेशन से साइट या ऐप्लिकेशन का ऐक्सेस हटाएं जिनके पास आपके खाते का ऐक्सेस है के सहायता दस्तावेज़ में, 'साइट या ऐप्लिकेशन का ऐक्सेस हटाएं' सेक्शन देखें.

    यह भी मुमकिन है कि कोई ऐप्लिकेशन, प्रोग्राम के हिसाब से अपने लिए दिया गया ऐक्सेस रद्द कर दे. प्रोग्राम के ज़रिए अनुमति रद्द करना तब ज़रूरी होता है, जब कोई उपयोगकर्ता सदस्यता रद्द करता है, किसी ऐप्लिकेशन को हटाता है या किसी ऐप्लिकेशन के लिए ज़रूरी एपीआई संसाधनों में काफ़ी बदलाव होता है. दूसरे शब्दों में, ऐप्लिकेशन को हटाने की प्रोसेस में एपीआई अनुरोध शामिल हो सकता है. इससे यह पक्का किया जा सकता है कि ऐप्लिकेशन को पहले दी गई अनुमतियां हटा दी गई हैं.

    PHP

    प्रोग्राम के हिसाब से टोकन रद्द करने के लिए, revokeToken() को कॉल करें:

    $client->revokeToken();

    Python

    प्रोग्राम के हिसाब से किसी टोकन को रद्द करने के लिए, https://oauth2.googleapis.com/revoke को एक अनुरोध भेजें. इसमें टोकन को पैरामीटर के तौर पर शामिल करें और Content-Type हेडर सेट करें:

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

    Ruby

    प्रोग्राम के हिसाब से टोकन रद्द करने के लिए, oauth2.revoke एंडपॉइंट पर एचटीटीपी अनुरोध करें:

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

    टोकन, ऐक्सेस टोकन या रीफ़्रेश टोकन हो सकता है. अगर टोकन ऐक्सेस टोकन है और उससे जुड़ा कोई रीफ़्रेश टोकन है, तो रीफ़्रेश टोकन भी रद्द कर दिया जाएगा.

    अगर रद्द करने की प्रोसेस पूरी हो जाती है, तो जवाब का स्टेटस कोड 200 होगा. गड़बड़ी की स्थितियों के लिए, गड़बड़ी कोड के साथ एक स्टेटस कोड 400 दिखाया जाता है.

    Node.js

    प्रोग्राम के हिसाब से टोकन रद्द करने के लिए, /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();

    टोकन पैरामीटर, ऐक्सेस टोकन या रीफ़्रेश टोकन हो सकता है. अगर टोकन ऐक्सेस टोकन है और उससे जुड़ा कोई रीफ़्रेश टोकन है, तो रीफ़्रेश टोकन भी रद्द कर दिया जाएगा.

    अगर रद्द करने की प्रोसेस पूरी हो जाती है, तो जवाब का स्टेटस कोड 200 होगा. गड़बड़ी की स्थितियों के लिए, गड़बड़ी कोड के साथ एक स्टेटस कोड 400 दिखाया जाता है.

    एचटीटीपी/REST

    प्रोग्राम के हिसाब से किसी टोकन को रद्द करने के लिए, आपका ऐप्लिकेशन https://oauth2.googleapis.com/revoke को अनुरोध भेजता है और टोकन को पैरामीटर के तौर पर शामिल करता है:

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

    टोकन, ऐक्सेस टोकन या रीफ़्रेश टोकन हो सकता है. अगर टोकन ऐक्सेस टोकन है और उससे जुड़ा कोई रीफ़्रेश टोकन है, तो रीफ़्रेश टोकन भी रद्द कर दिया जाएगा.

    अगर रद्द करने की प्रोसेस पूरी हो जाती है, तो रिस्पॉन्स का एचटीटीपी स्टेटस कोड 200 होगा. गड़बड़ी की स्थितियों के लिए, गड़बड़ी के कोड के साथ एक एचटीटीपी स्टेटस कोड 400 दिखाया जाता है.

    'सभी खातों की सुरक्षा' सुविधा लागू करना

    अपने उपयोगकर्ताओं के खातों को सुरक्षित रखने के लिए, आपको एक और कदम उठाना चाहिए. इसके लिए, Google की क्रॉस-खाता सुरक्षा सेवा का इस्तेमाल करके, क्रॉस-खाता सुरक्षा लागू करें. इस सेवा की मदद से, आपके पास सुरक्षा से जुड़े इवेंट की सूचनाएं पाने की सदस्यता लेने का विकल्प होता है. इन सूचनाओं से, आपके ऐप्लिकेशन को उपयोगकर्ता खाते में हुए बड़े बदलावों के बारे में जानकारी मिलती है. इसके बाद, इस जानकारी का इस्तेमाल करके कार्रवाई की जा सकती है. यह इस बात पर निर्भर करता है कि आपने इवेंट के जवाब में क्या किया है.

    Google की क्रॉस-खाता सुरक्षा सेवा, आपके ऐप्लिकेशन पर इस तरह के इवेंट भेजती है:

    • https://schemas.openid.net/secevent/risc/event-type/sessions-revoked
    • https://schemas.openid.net/secevent/oauth/event-type/token-revoked
    • https://schemas.openid.net/secevent/risc/event-type/account-disabled

    सभी खातों की सुरक्षा की सुविधा को लागू करने के तरीके और उपलब्ध इवेंट की पूरी सूची के बारे में ज़्यादा जानने के लिए, सभी खातों की सुरक्षा की सुविधा की मदद से उपयोगकर्ता खातों को सुरक्षित रखें पेज पर जाएं .