Google Ads और मेज़रमेंट कम्यूनिटी के Discord सर्वर और YouTube पर, 15 अक्टूबर को सुबह 10:00 बजे ईएसटी में हमारे साथ लाइव जुड़ें! हम Google Ads API के वर्शन 26 में जोड़ी गई नई सुविधाओं के बारे में चर्चा करेंगे.

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

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

अन्य Google API की तरह, 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 CLI या generate_user_credentials कोड के उदाहरण जैसे किसी टूल को चलाता है. इससे आपके ऐप्लिकेशन को, उसके सभी Google Ads खातों को उसकी ओर से मैनेज करने की अनुमति मिलती है.

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

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

अपने लोकल एनवायरमेंट में, ऐप्लिकेशन के डिफ़ॉल्ट क्रेडेंशियल (एडीसी) सेट अप करने के लिए, क्रेडेंशियल जनरेट करने से जुड़ा दस्तावेज़ देखें.
अपनी 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 की क्लाइंट लाइब्रेरी में, ऐसे मामलों को मैनेज करने का तरीका बताने वाले ये कोड के उदाहरण दिए गए हैं:

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