Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

पुष्टि करना और अनुमति देना

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

Google Ads के ऐक्सेस मॉडल को समझना

Google Ads API का असरदार तरीके से इस्तेमाल करने के लिए, Google Ads के ऐक्सेस मॉडल के काम करने का तरीका समझें. Google Ads ऐक्सेस मॉडल गाइड देखें.

OAuth वर्कफ़्लो

Google Ads API का इस्तेमाल करते समय, तीन सामान्य वर्कफ़्लो इस्तेमाल किए जाते हैं.

सेवा खाते का फ़्लो

अगर आपके वर्कफ़्लो में किसी व्यक्ति के इंटरैक्शन की ज़रूरत नहीं है, तो हमारा सुझाव है कि आप यह वर्कफ़्लो अपनाएं. इस वर्कफ़्लो के लिए, कॉन्फ़िगरेशन का एक चरण ज़रूरी है. इसमें उपयोगकर्ता को अपने Google Ads खाते में सेवा खाता जोड़ना होता है. इसके बाद, ऐप्लिकेशन उपयोगकर्ता के Google Ads खाते को मैनेज करने के लिए, सेवा खाते के क्रेडेंशियल का इस्तेमाल कर सकता है. Python लाइब्रेरी को इस तरह कॉन्फ़िगर किया गया है:

अगर google-ads.yaml फ़ाइल या YAML स्ट्रिंग का इस्तेमाल किया जा रहा है, तो अपने लोकल एनवायरमेंट में निजी पासकोड वाली JSON फ़ाइल का पाथ सेट करने के लिए, अपने कॉन्फ़िगरेशन में यह जानकारी जोड़ें. साथ ही, अगर पूरे डोमेन के लिए ऐक्सेस देने की सुविधा का इस्तेमाल किया जा रहा है, तो वैकल्पिक impersonated_email भी जोड़ें:
```
json_key_file_path: JSON_KEY_FILE_PATH
# Optional: only set if using Google Workspace domain-wide delegation:
# impersonated_email: IMPERSONATED_EMAIL
```
इसके बाद, load_from_storage या load_from_string वाले तरीके को कॉल करें:
```
from google.ads.googleads.client import GoogleAdsClient

client = GoogleAdsClient.load_from_storage()
```
अगर लाइब्रेरी को कॉन्फ़िगर करने के लिए dict का इस्तेमाल किया जा रहा है, तो यहां दिया गया की-वैल्यू पेयर शामिल करें. साथ ही, कॉन्फ़िगरेशन dict को पास करते हुए load_from_dict तरीके को कॉल करें:
```
from google.ads.googleads.client import GoogleAdsClient

configuration = {
    # ...
    "json_key_file_path": JSON_KEY_FILE_PATH,
    # ...
}

client = GoogleAdsClient.load_from_dict(configuration)
```
अगर एनवायरमेंट वैरिएबल का इस्तेमाल किया जा रहा है, तो अपने bash कॉन्फ़िगरेशन या एनवायरमेंट में यह जोड़ें:
```
export GOOGLE_ADS_JSON_KEY_FILE_PATH=JSON_KEY_FILE_PATH
```
इसके बाद, load_from_env वाले तरीके को कॉल करें:
```
from google.ads.googleads.client import GoogleAdsClient

client = GoogleAdsClient.load_from_env()
```

अगर कॉन्फ़िगरेशन के इनमें से किसी भी तरीके में json_key_file_path कॉन्फ़िगरेशन विकल्प मौजूद है, तो use_application_default_credentials विकल्प False है या सेट नहीं है. साथ ही, OAuth उपयोगकर्ता क्रेडेंशियल कुंजियां (client_id, client_secret, और refresh_token) सेट नहीं हैं या टिप्पणी के तौर पर मार्क की गई हैं, तो लाइब्रेरी, सेवा खाते के फ़्लो का इस्तेमाल करके अपने-आप अनुमति देती है.

ज़्यादा जानने के लिए, सेवा खाते के वर्कफ़्लो की गाइड देखें.

एक उपयोगकर्ता की पुष्टि करने का फ़्लो

अगर सेवा खातों का इस्तेमाल नहीं किया जा सकता, तो इस वर्कफ़्लो का इस्तेमाल किया जा सकता है. इस वर्कफ़्लो को कॉन्फ़िगर करने के लिए, दो चरणों को पूरा करना ज़रूरी है:

Google Ads API का इस्तेमाल करके, किसी एक उपयोगकर्ता को उन सभी खातों का ऐक्सेस दें जिन्हें मैनेज करना है. आम तौर पर, उपयोगकर्ता को Google Ads API मैनेजर खाते का ऐक्सेस दिया जाता है. साथ ही, सभी Google Ads खातों को उस मैनेजर खाते से लिंक किया जाता है.
उपयोगकर्ता, gcloud सीएलआई या generate_user_credentials कोड के उदाहरण जैसे किसी टूल का इस्तेमाल करके, आपके ऐप्लिकेशन को अपने सभी Google Ads खातों को मैनेज करने की अनुमति देता है.

उपयोगकर्ता के OAuth 2.0 क्रेडेंशियल का इस्तेमाल करके, लाइब्रेरी को इस तरह शुरू किया जा सकता है:

gcloud सीएलआई टूल का इस्तेमाल करने पर (सुझाया गया)

अपने लोकल एनवायरमेंट में ऐप्लिकेशन डिफ़ॉल्ट क्रेडेंशियल (एडीसी) सेट अप करने के लिए, क्रेडेंशियल जनरेट करें दस्तावेज़ में दिया गया तरीका अपनाएं.
अपनी google-ads.yaml या YAML स्ट्रिंग में यह कॉन्फ़िगरेशन जोड़ें:
```
use_application_default_credentials: true
```
इसके बाद, load_from_storage या load_from_string वाले तरीके को कॉल करें:
```
from google.ads.googleads.client import GoogleAdsClient

client = GoogleAdsClient.load_from_storage()
```
अगर लाइब्रेरी को कॉन्फ़िगर करने के लिए dict का इस्तेमाल किया जाता है, तो यहां दिया गया की-वैल्यू पेयर शामिल करें और load_from_dict तरीके को कॉल करें:
```
from google.ads.googleads.client import GoogleAdsClient

configuration = {
    # ...
    "use_application_default_credentials": True,
    # ...
}

client = GoogleAdsClient.load_from_dict(configuration)
```
अगर एनवायरमेंट वैरिएबल का इस्तेमाल किया जा रहा है, तो अपने bash कॉन्फ़िगरेशन या एनवायरमेंट में यह जोड़ें:
```
export GOOGLE_ADS_USE_APPLICATION_DEFAULT_CREDENTIALS=true
```
इसके बाद, load_from_env वाले तरीके को कॉल करें:
```
from google.ads.googleads.client import GoogleAdsClient

client = GoogleAdsClient.load_from_env()
```

अगर OAuth टोकन को सीधे तौर पर मैनेज किया जा रहा है

कंसोल प्रोजेक्ट सेट अप करने के लिए, यह तरीका अपनाएं. साथ ही, वह JSON फ़ाइल डाउनलोड करें जिसमें आपके प्रोजेक्ट का क्लाइंट आईडी और क्लाइंट सीक्रेट शामिल हो.
Python क्लाइंट लाइब्रेरी को अपनी मशीन में क्लोन करें और उसकी डायरेक्ट्री में जाएं:
```
git clone https://github.com/googleads/google-ads-python.git
cd google-ads-python
```
पहले चरण में डाउनलोड की गई JSON फ़ाइल का ऐब्सलूट पाथ देकर, उदाहरण को लागू करें:
```
python examples/authentication/generate_user_credentials.py \
    -c PATH_TO_CREDENTIALS_JSON
```
प्रोसेस पूरी होने के बाद, आपके कंसोल पर रीफ़्रेश टोकन दिखता है. इसे कॉपी करें और अगले चरण के लिए सेव करें.
अपनी पसंद के कॉन्फ़िगरेशन में ये सेटिंग जोड़कर, लाइब्रेरी को कॉन्फ़िगर करें:

अपनी google-ads.yaml या YAML स्ट्रिंग में यह कॉन्फ़िगरेशन जोड़ें:
```
client_id: INSERT_OAUTH2_CLIENT_ID_HERE
client_secret: INSERT_OAUTH2_CLIENT_SECRET_HERE
refresh_token: INSERT_REFRESH_TOKEN_HERE
```
इसके बाद, load_from_storage या load_from_string वाले तरीके को कॉल करें:
```
from google.ads.googleads.client import GoogleAdsClient

client = GoogleAdsClient.load_from_storage()
```
अगर लाइब्रेरी को कॉन्फ़िगर करने के लिए dict का इस्तेमाल किया जा रहा है, तो यहां दिए गए की-वैल्यू पेयर शामिल करें और load_from_dict तरीके को कॉल करें:
```
from google.ads.googleads.client import GoogleAdsClient

configuration = {
    # ...
    "client_id": INSERT_OAUTH2_CLIENT_ID_HERE,
    "client_secret": (
        INSERT_OAUTH2_CLIENT_SECRET_HERE
    ),
    "refresh_token": INSERT_REFRESH_TOKEN_HERE,
    # ...
}

client = GoogleAdsClient.load_from_dict(configuration)
```
अगर एनवायरमेंट वैरिएबल का इस्तेमाल किया जा रहा है, तो अपने bash कॉन्फ़िगरेशन या एनवायरमेंट में यह जोड़ें:
```
export GOOGLE_ADS_CLIENT_ID=\
INSERT_OAUTH2_CLIENT_ID_HERE
export GOOGLE_ADS_CLIENT_SECRET=\
INSERT_OAUTH2_CLIENT_SECRET_HERE
export GOOGLE_ADS_REFRESH_TOKEN=\
INSERT_REFRESH_TOKEN_HERE
```
इसके बाद, load_from_env वाले तरीके को कॉल करें:
```
from google.ads.googleads.client import GoogleAdsClient

client = GoogleAdsClient.load_from_env()
```

ज़्यादा जानने के लिए, एक उपयोगकर्ता की पुष्टि करने वाले वर्कफ़्लो की गाइड देखें.

डिवाइस के एक से ज़्यादा उपयोगकर्ताओं की पुष्टि करने का फ़्लो

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

dict, रनटाइम के दौरान क्रेडेंशियल पाने के लिए इस्तेमाल किया जाने वाला सबसे आसान कॉन्फ़िगरेशन तरीका है:

from google.ads.googleads.client import GoogleAdsClient

configuration = {
    # ...
    "client_id": client_id,
    "client_secret": client_secret,
    "refresh_token": refresh_token,
    # ...
}

client = GoogleAdsClient.load_from_dict(configuration)

ज़्यादा जानने के लिए, डिवाइस के एक से ज़्यादा उपयोगकर्ताओं की पुष्टि करने के वर्कफ़्लो की गाइड देखें.

मैन्युअल तरीके से पुष्टि करना

किसी भी तरीके से, पुष्टि करने के क्रेडेंशियल जनरेट किए जा सकते हैं. इसके बाद, क्लाइंट क्लास को सीधे इंस्टैंशिएट करके, GoogleAdsClient को मैन्युअल तरीके से क्रेडेंशियल दिए जा सकते हैं. मान लें कि आपने जो क्रेडेंशियल ऑब्जेक्ट बनाया है वह google.auth.credentials.Credentials का इंस्टेंस है, तो उसे इस तरह पास किया जा सकता है:

from google.ads.googleads.client import GoogleAdsClient
from google.auth import default

# This line retrieves ADCs from the environment. You can use any authentication
# approach as long as the `credentials` variable is an instance of
# `google.auth.credentials.Credentials`.
credentials, _ = default(scopes=["https://www.googleapis.com/auth/adwords"])

client = GoogleAdsClient(
    credentials=credentials,
    use_proto_plus=True,
)

एक से ज़्यादा खाते प्रबंधित करना

आम तौर पर, कोई उपयोगकर्ता एक से ज़्यादा Google Ads खाते मैनेज करता है. इसके लिए, वह खातों को सीधे ऐक्सेस करता है या Google Ads मैनेजर खाते का इस्तेमाल करता है. Python क्लाइंट लाइब्रेरी में, यहां दिए गए कोड के उदाहरणों से पता चलता है कि इस तरह के मामलों को कैसे मैनेज किया जाए:

get_account_hierarchy कोड के उदाहरण से पता चलता है कि Google Ads मैनेजर खाते के तहत, सभी खातों की सूची को कैसे वापस लाया जाए.
list_accessible_customers कोड के उदाहरण से पता चलता है कि उन सभी खातों की सूची कैसे वापस पाई जा सकती है जिनका उपयोगकर्ता के पास सीधा ऐक्सेस है. इसके बाद, इन खातों का इस्तेमाल login_customer_id सेटिंग के लिए मान्य वैल्यू के तौर पर किया जा सकता है.