सबसे अच्छे तरीके

इस पेज पर, Google Ads स्क्रिप्ट का इस्तेमाल करके डेवलपमेंट करने के सबसे सही तरीकों के बारे में बताया गया है.

सिलेक्टर

चुनने वालों के हिसाब से फ़िल्टर करना

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

  • कोड को समझना और इस्तेमाल करना आसान है.
  • स्क्रिप्ट बहुत तेज़ी से काम करेगी.

यहां दिए गए कोड स्निपेट की तुलना करें:

कोडिंग का तरीका कोड स्निपेट
सलेक्टर का इस्तेमाल करके फ़िल्टर करना (इसका सुझाव दिया जाता है) 
var keywords = AdsApp.keywords()
    .withCondition('Clicks > 10')
    .forDateRange('LAST_MONTH')
    .get();
while (keywords.hasNext()) {
  var keyword = keywords.next();
  // Do work here.
}
कोड में फ़िल्टर करना (इसका सुझाव नहीं दिया जाता) 
var keywords = AdsApp.keywords().get();

while (keywords.hasNext()) {
  var keyword = keywords.next();
  var stats = keyword.getStatsFor(
      'LAST_MONTH');
  if (stats.getClicks() > 10) {
    // Do work here.
  }
}

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

कैंपेन हैरारकी को ट्रैवर्स करने से बचें

जब आपको किसी खास लेवल पर मौजूद इकाइयां वापस लानी हों, तो पूरे कैंपेन के क्रम में जाने के बजाय, उस लेवल पर मौजूद कलेक्शन मेथड का इस्तेमाल करें. यह तरीका आसान होने के साथ-साथ, बेहतर तरीके से काम करेगा. सिस्टम को सभी कैंपेन और विज्ञापन ग्रुप को गैर-ज़रूरी तौर पर नहीं पढ़ना पड़ेगा.

अपने खाते में मौजूद सभी विज्ञापनों को वापस पाने वाले इन कोड स्निपेट की तुलना करें:

कोडिंग का तरीका कोड स्निपेट
डेटा इकट्ठा करने के सही तरीके का इस्तेमाल करें (सुझाया गया) 

var ads = AdsApp.ads();
हैरारकी को ट्रैवर्स करना (इसका सुझाव नहीं दिया जाता) 
var campaigns = AdsApp.campaigns().get();
while (campaigns.hasNext()) {
  var adGroups = campaigns.next().
      adGroups().get();
  while (adGroups.hasNext()) {
    var ads = adGroups.next().ads().get();
    // Do your work here.
  }
}

हमारा सुझाव है कि आप दूसरा तरीका न अपनाएं. ऐसा इसलिए, क्योंकि यह ऑब्जेक्ट (कैंपेन, विज्ञापन ग्रुप) की पूरी हैरारकी को फ़ेच करने की कोशिश करता है, जबकि सिर्फ़ विज्ञापनों की ज़रूरत होती है.

अभिभावक के लिए निजी डेटा लाने के खास तरीकों का इस्तेमाल करना

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

यहां दिए गए कोड स्निपेट की तुलना करें. ये ऐसे विज्ञापन ग्रुप को वापस लाते हैं जिनमें पिछले महीने 50 से ज़्यादा क्लिक वाले टेक्स्ट विज्ञापन थे:

कोडिंग का तरीका कोड स्निपेट
पैरंट ऐक्सेसर के सही तरीके का इस्तेमाल करना (इसका सुझाव दिया जाता है) 
var ads = AdsApp.ads()
    .withCondition('Clicks > 50')
    .forDateRange('LAST_MONTH')
    .get();

while (ads.hasNext()) {
  var ad = ads.next();
  var adGroup = ad.getAdGroup();
  var campaign = ad.getCampaign();
  // Store (campaign, adGroup) to an array.
}
हैरारकी को ट्रैवर्स करना (हम इसका सुझाव नहीं देते) 
var campaigns = AdsApp.campaigns().get();
while (campaigns.hasNext()) {
  var adGroups = campaigns.next()
      .adGroups()
      .get();
  while (adGroups.hasNext()) {
    var ads = adGroups.ads()
       .withCondition('Clicks > 50')
       .forDateRange('LAST_MONTH')
       .get();
    if (ads.totalNumEntities() > 0) {
      // Store (campaign, adGroup) to an array.
    }
  }
}

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

अभिभावक के लिए बने फ़िल्टर का इस्तेमाल करना

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

यहां दिए गए कोड स्निपेट की तुलना करें. ये स्निपेट, किसी कैंपेन और विज्ञापन ग्रुप में मौजूद टेक्स्ट विज्ञापनों की सूची को फिर से हासिल करते हैं. इस कैंपेन और विज्ञापन ग्रुप को पिछले महीने 50 से ज़्यादा क्लिक मिले थे.

कोडिंग का तरीका कोड स्निपेट
पैरंट लेवल के सही फ़िल्टर इस्तेमाल करना (इसका सुझाव दिया जाता है) 
var ads = AdsApp.ads()
    .withCondition('CampaignName = "Campaign 1"')
    .withCondition('AdGroupName = "AdGroup 1"')
    .withCondition('Clicks > 50')
    .forDateRange('LAST_MONTH')
    .get();

while (ads.hasNext()) {
  var ad = ads.next();
  var adGroup = ad.getAdGroup();
  var campaign = ad.getCampaign();
  // Store (campaign, adGroup, ad) to
  // an array.
}
हैरारकी को ट्रैवर्स करना (हम इसका सुझाव नहीं देते) 
var campaigns = AdsApp.campaigns()
    .withCondition('Name = "Campaign 1"')
    .get();

while (campaigns.hasNext()) {
  var adGroups = campaigns.next()
      .adGroups()
      .withCondition('Name = "AdGroup 1"')
      .get();
  while (adGroups.hasNext()) {
    var ads = adGroups.ads()
       .withCondition('Clicks > 50')
       .forDateRange('LAST_MONTH')
       .get();
    while (ads.hasNext()) {
      var ad = ads.next();
      // Store (campaign, adGroup, ad) to
      // an array.
    }
  }
}

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

जब मुमकिन हो, तब फ़िल्टर करने के लिए आईडी का इस्तेमाल करें

इकाइयों के लिए फ़िल्टर करते समय, अन्य फ़ील्ड के बजाय उनके आईडी के हिसाब से फ़िल्टर करना बेहतर होता है.

कैंपेन चुनने वाले इन कोड स्निपेट पर ध्यान दें.

कोडिंग का तरीका कोड स्निपेट
आईडी के हिसाब से फ़िल्टर करना (हम इसका सुझाव देते हैं) 
var campaign = AdsApp.campaigns()
    .withIds([12345])
    .get()
    .next();
नाम के हिसाब से फ़िल्टर करें (कम बेहतर) 
var campaign = AdsApp.campaigns()
    .withCondition('Name="foo"')
    .get()
    .next();

दूसरा तरीका कम बेहतर है, क्योंकि हम आईडी के अलावा किसी दूसरे फ़ील्ड के हिसाब से फ़िल्टर कर रहे हैं.

जब भी मुमकिन हो, पैरंट आईडी के हिसाब से फ़िल्टर करें

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

यहां दिए गए कोड स्निपेट पर विचार करें. यह कोड स्निपेट, विज्ञापन ग्रुप को उसके आईडी से वापस पाता है. मान लें कि पैरंट कैंपेन आईडी का पता है.

कोडिंग का तरीका कोड स्निपेट
कैंपेन और विज्ञापन ग्रुप आईडी के हिसाब से फ़िल्टर करें (सुझाया गया) 
var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .withCondition('CampaignId="54678"')
    .get()
    .next();
सिर्फ़ विज्ञापन ग्रुप आईडी के हिसाब से फ़िल्टर करना (कम बेहतर) 
var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .get()
    .next();

दोनों कोड स्निपेट से एक जैसे नतीजे मिलते हैं. हालांकि, कोड स्निपेट 1 में पैरंट आईडी (CampaignId="54678") का इस्तेमाल करके अतिरिक्त फ़िल्टरिंग की जाती है. इससे कोड ज़्यादा असरदार हो जाता है, क्योंकि यह उन इकाइयों की सूची को सीमित कर देता है जिन्हें सर्वर को नतीजों को फ़िल्टर करते समय दोहराना पड़ता है.

फ़िल्टर करने की कई शर्तें होने पर लेबल का इस्तेमाल करना

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

यहां दिए गए कोड के स्निपेट पर ध्यान दें. यह कोड, नाम के हिसाब से कैंपेन की सूची को वापस लाता है.

कोडिंग का तरीका कोड स्निपेट
लेबल का इस्तेमाल करना (इसका सुझाव दिया जाता है) 
var label = AdsApp.labels()
    .withCondition('Name = "My Label"')
    .get()
    .next();
var campaigns = label.campaigns.get();
while (campaigns.hasNext()) {
  var campaign = campaigns.next();
  // Do more work
}
मुश्किल सिलेक्टर बनाना (इसका सुझाव नहीं दिया जाता) 
var campaignNames = ['foo', 'bar', 'baz'];

for (var i = 0; i < campaignNames.length; i++) {
  campaignNames[i] = '"' + campaignNames[i] + '"';
}

var campaigns = AdsApp.campaigns
    .withCondition('CampaignName in [' + campaignNames.join(',') + ']')
    .get();

while (campaigns.hasNext()) {
  var campaign = campaigns.next();
  // Do more work.
}

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

IN क्लॉज़ में शर्तों की संख्या सीमित करें

स्क्रिप्ट चलाने के दौरान, आम तौर पर कई इकाइयों के लिए रिपोर्ट जनरेट की जाती है. डेवलपर आम तौर पर, IN क्लॉज़ का इस्तेमाल करके, इकाई आईडी के हिसाब से फ़िल्टर करने वाली बहुत लंबी AWQL क्वेरी बनाते हैं. जब इकाइयों की संख्या सीमित होती है, तब यह तरीका ठीक से काम करता है. हालांकि, क्वेरी की लंबाई बढ़ने पर, आपकी स्क्रिप्ट की परफ़ॉर्मेंस में गिरावट आती है. इसकी दो वजहें हैं:

  • लंबी क्वेरी को पार्स करने में ज़्यादा समय लगता है.
  • IN क्लॉज़ में जोड़ा गया हर आईडी, आकलन करने के लिए एक अतिरिक्त शर्त होती है. इसलिए, इसमें ज़्यादा समय लगता है.

ऐसी स्थितियों में, इकाइयों पर लेबल लगाना बेहतर होता है. इसके बाद, LabelId के हिसाब से फ़िल्टर करें.

कोडिंग का तरीका कोड स्निपेट
लेबल लागू करना और labelID के हिसाब से फ़िल्टर करना (सुझाया गया) 
// The label applied to the entity is "Report Entities"
var label = AdsApp.labels()
    .withCondition('LabelName contains "Report Entities"')
    .get()
    .next();

var report = AdsApp.report('SELECT AdGroupId, Id, Clicks, ' +
    'Impressions, Cost FROM KEYWORDS_PERFORMANCE_REPORT ' +
    'WHERE LabelId = "' + label.getId() + '"');
IN क्लॉज़ का इस्तेमाल करके लंबी क्वेरी बनाना (इसका सुझाव नहीं दिया जाता) 
var report = AdsApp.report('SELECT AdGroupId, Id, Clicks, ' +
    'Impressions, Cost FROM KEYWORDS_PERFORMANCE_REPORT WHERE ' +
    'AdGroupId IN (123, 456) and Id in (123,345, 456…)');

खाते से जुड़े अपडेट

एक साथ कई बदलाव करना

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

यहां दी गई स्क्रिप्ट, कीवर्ड की सूची के लिए बिड अपडेट करती है.

कोडिंग का तरीका कोड स्निपेट
अपडेट किए गए एलिमेंट को ट्रैक करना (सुझाया गया) 
var keywords = AdsApp.keywords()
    .withCondition('Clicks > 50')
    .withCondition('CampaignName = "Campaign 1"')
    .withCondition('AdGroupName = "AdGroup 1"')
    .forDateRange('LAST_MONTH')
    .get();

var list = [];
while (keywords.hasNext()) {
  var keyword = keywords.next();
  keyword.bidding().setCpc(1.5);
  list.push(keyword);
}

for (var i = 0; i < list.length; i++) {
  var keyword = list[i];
  Logger.log('%s, %s', keyword.getText(),
      keyword.bidding().getCpc());
}
अपडेट किए गए एलिमेंट को टाइट लूप में वापस पाना (इसका सुझाव नहीं दिया जाता) 
var keywords = AdsApp.keywords()
    .withCondition('Clicks > 50')
    .withCondition('CampaignName = "Campaign 1"')
    .withCondition('AdGroupName = "AdGroup 1"')
    .forDateRange('LAST_MONTH')
    .get();

while (keywords.hasNext()) {
  var keyword = keywords.next();
  keyword.bidding().setCpc(1.5);
  Logger.log('%s, %s', keyword.getText(),
      keyword.bidding().getCpc());
}

हमारा सुझाव है कि आप दूसरे तरीके का इस्तेमाल न करें. ऐसा इसलिए, क्योंकि keyword.bidding().getCpc() को कॉल करने पर, Google Ads स्क्रिप्ट को setCpc() ऑपरेशन को फ़्लश करना पड़ता है. साथ ही, एक बार में सिर्फ़ एक ऑपरेशन को लागू करना पड़ता है. पहला तरीका, दूसरे तरीके से मिलता-जुलता है. हालांकि, इसमें बैचिंग की सुविधा भी मिलती है. ऐसा इसलिए, क्योंकि getCpc() कॉल को उस लूप से अलग लूप में किया जाता है जहां setCpc() को कॉल किया जाता है.

जब हो सके, तब बिल्डर का इस्तेमाल करें

Google Ads स्क्रिप्ट में, नए ऑब्जेक्ट बनाने के दो तरीके उपलब्ध हैं: बिल्डर और ऑब्जेक्ट बनाने के तरीके. बिल्डर, ऑब्जेक्ट बनाने के तरीकों से ज़्यादा फ़्लेक्सिबल होते हैं. ऐसा इसलिए, क्योंकि इससे आपको एपीआई कॉल से बनाए गए ऑब्जेक्ट का ऐक्सेस मिलता है.

यहां दिए गए कोड स्निपेट देखें:

कोडिंग का तरीका कोड स्निपेट
बिल्डर का इस्तेमाल करना (इसका सुझाव दिया जाता है) 
var operation = adGroup.newKeywordBuilder()
    .withText('shoes')
    .build();
var keyword = operation.getResult();
नीति बनाने के तरीकों का इस्तेमाल करना (इसका सुझाव नहीं दिया जाता) 
adGroup.createKeyword('shoes');
var keyword = adGroup.keywords()
    .withCondition('KeywordText="shoes"')
    .get()
    .next();

कीवर्ड को वापस पाने के लिए, अतिरिक्त सिलेक्शन ऑपरेशन की वजह से दूसरे तरीके को प्राथमिकता नहीं दी जाती. इसके अलावा, वीडियो बनाने के तरीके भी अब काम नहीं करेंगे.

हालांकि, ध्यान रखें कि बिल्डर का गलत तरीके से इस्तेमाल करने पर, Google Ads स्क्रिप्ट को एक साथ कई कार्रवाइयां करने से रोका जा सकता है.

यहां दिए गए कोड स्निपेट देखें. इनसे कीवर्ड की सूची बनाई जाती है और नए कीवर्ड का आईडी प्रिंट किया जाता है:

कोडिंग का तरीका कोड स्निपेट
अपडेट किए गए एलिमेंट को ट्रैक करना (सुझाया गया) 
var keywords = ['foo', 'bar', 'baz'];

var list = [];
for (var i = 0; i < keywords.length; i++) {
  var operation = adGroup.newKeywordBuilder()
      .withText(keywords[i])
      .build();
  list.push(operation);
}

for (var i = 0; i < list.length; i++) {
  var operation = list[i];
  var result = operation.getResult();
  Logger.log('%s %s', result.getId(),
      result.getText());
}
अपडेट किए गए एलिमेंट को टाइट लूप में वापस पाना (इसका सुझाव नहीं दिया जाता) 
var keywords = ['foo', 'bar', 'baz'];

for (var i = 0; i < keywords.length; i++) {
  var operation = adGroup.newKeywordBuilder()
      .withText(keywords[i])
      .build();
  var result = operation.getResult();
  Logger.log('%s %s', result.getId(),
      result.getText());
}

दूसरे तरीके का इस्तेमाल करने का सुझाव नहीं दिया जाता, क्योंकि यह उस लूप के अंदर operation.getResult() को कॉल करता है जो ऑपरेशन बनाता है. इसलिए, Google Ads स्क्रिप्ट को एक बार में एक ही ऑपरेशन को लागू करना पड़ता है. पहला तरीका, दूसरे तरीके से मिलता-जुलता है. हालांकि, इसमें बैचिंग की अनुमति है, क्योंकि हम operation.getResult() को उस लूप से अलग लूप में कॉल करते हैं जहां इसे बनाया गया था.

बड़े अपडेट के लिए, एक साथ कई फ़ाइलें अपलोड करने की सुविधा का इस्तेमाल करें

डेवलपर, आम तौर पर रिपोर्ट जनरेट करते हैं. साथ ही, मौजूदा परफ़ॉर्मेंस वैल्यू के आधार पर, इकाई की प्रॉपर्टी (उदाहरण के लिए, कीवर्ड बिड) अपडेट करते हैं. जब आपको बड़ी संख्या में इकाइयों को अपडेट करना हो, तो बल्क अपलोड से आपको बेहतर परफ़ॉर्मेंस मिलती है. उदाहरण के लिए, यहां दी गई स्क्रिप्ट देखें. ये स्क्रिप्ट, उन कीवर्ड के लिए MaxCpc बढ़ाती हैं जिनके लिए पिछले महीने TopImpressionPercentage > 0.4:

कोडिंग का तरीका कोड स्निपेट
एक साथ कई फ़ाइलें अपलोड करने की सुविधा का इस्तेमाल करना (इसका सुझाव दिया जाता है) 

var report = AdsApp.report(
  'SELECT AdGroupId, Id, CpcBid FROM KEYWORDS_PERFORMANCE_REPORT ' +
  'WHERE TopImpressionPercentage > 0.4 DURING LAST_MONTH');

var upload = AdsApp.bulkUploads().newCsvUpload([
  report.getColumnHeader('AdGroupId').getBulkUploadColumnName(),
  report.getColumnHeader('Id').getBulkUploadColumnName(),
  report.getColumnHeader('CpcBid').getBulkUploadColumnName()]);
upload.forCampaignManagement();

var reportRows = report.rows();
while (reportRows.hasNext()) {
  var row = reportRows.next();
  row['CpcBid'] = row['CpcBid'] + 0.02;
  upload.append(row.formatForUpload());
}

upload.apply();
आईडी के हिसाब से कीवर्ड चुनना और उन्हें अपडेट करना (यह तरीका ज़्यादा सही नहीं है) 
var reportRows = AdsApp.report('SELECT AdGroupId, Id, CpcBid FROM ' +
    'KEYWORDS_PERFORMANCE_REPORT WHERE TopImpressionPercentage > 0.4 ' +
    ' DURING LAST_MONTH')
    .rows();

var map = {
};

while (reportRows.hasNext()) {
  var row = reportRows.next();
  var adGroupId = row['AdGroupId'];
  var id = row['Id'];

  if (map[adGroupId] == null) {
    map[adGroupId] = [];
  }
  map[adGroupId].push([adGroupId, id]);
}

for (var key in map) {
  var keywords = AdsApp.keywords()
      .withCondition('AdGroupId="' + key + '"')
      .withIds(map[key])
      .get();

  while (keywords.hasNext()) {
    var keyword = keywords.next();
    keyword.bidding().setCpc(keyword.bidding().getCpc() + 0.02);
  }
}

दूसरे तरीके से आपको अच्छी परफ़ॉर्मेंस मिलती है. हालांकि, इस मामले में पहले तरीके को प्राथमिकता दी जाती है, क्योंकि

  • Google Ads स्क्रिप्ट में, एक बार में वापस पाए जा सकने वाले या अपडेट किए जा सकने वाले ऑब्जेक्ट की संख्या सीमित होती है. दूसरे तरीके में, चुनने और अपडेट करने की कार्रवाइयां उस सीमा में शामिल होती हैं.

  • बल्क में अपलोड करने की सुविधा में, अपडेट की जा सकने वाली इकाइयों की संख्या और कुल समय, दोनों के हिसाब से ज़्यादा सीमाएं होती हैं.

एक साथ कई फ़ाइलें अपलोड करने की सुविधा का इस्तेमाल करके, कैंपेन के हिसाब से फ़ाइलें ग्रुप करना

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

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

Google Ads स्क्रिप्ट, एक साथ कई फ़ाइलें अपलोड करने के एक टास्क को ऑप्टिमाइज़ कर सकती हैं. इसलिए, सबसे आसान तरीका यह है कि एक समय में हर खाते के लिए, एक साथ कई फ़ाइलें अपलोड करने का सिर्फ़ एक टास्क चलाया जाए. अगर आपको हर खाते के लिए एक से ज़्यादा बार में डेटा अपलोड करना है, तो पक्का करें कि हर बार में डेटा अपलोड करने के लिए, कैंपेन (और उनकी चाइल्ड इकाइयां) की अलग-अलग सूची का इस्तेमाल किया जाए. इससे आपको बेहतर परफ़ॉर्मेंस मिलेगी.

रिपोर्टिंग

आंकड़े पाने के लिए रिपोर्ट का इस्तेमाल करना

जब आपको बड़ी संख्या में इकाइयों और उनके आंकड़े वापस पाने हों, तो अक्सर AdsApp के स्टैंडर्ड तरीकों के बजाय रिपोर्ट का इस्तेमाल करना बेहतर होता है. रिपोर्ट का इस्तेमाल करने को प्राथमिकता दी जाती है. इसकी वजहें यहां दी गई हैं:

  • रिपोर्ट की मदद से, बड़ी क्वेरी को बेहतर तरीके से प्रोसेस किया जा सकता है.
  • रिपोर्ट, डेटा फ़ेच करने के सामान्य कोटे पर असर नहीं डालेंगी.

यहां दिए गए कोड स्निपेट की तुलना करें. ये स्निपेट, उन सभी कीवर्ड के क्लिक, इंप्रेशन, लागत, और टेक्स्ट फ़ेच करते हैं जिन्हें पिछले महीने 50 से ज़्यादा क्लिक मिले हैं:

कोडिंग का तरीका कोड स्निपेट
रिपोर्ट का इस्तेमाल करना (सुझाया गया) 
  report = AdsApp.search(
      'SELECT ' +
      '   ad_group_criterion.keyword.text, ' +
      '   metrics.clicks, ' +
      '   metrics.cost_micros, ' +
      '   metrics.impressions ' +
      'FROM ' +
      '   keyword_view ' +
      'WHERE ' +
      '   segments.date DURING LAST_MONTH ' +
      '   AND metrics.clicks > 50');
  while (report.hasNext()) {
    var row = report.next();
    Logger.log('Keyword: %s Impressions: %s ' +
        'Clicks: %s Cost: %s',
        row.adGroupCriterion.keyword.text,
        row.metrics.impressions,
        row.metrics.clicks,
        row.metrics.cost);
  }
AdsApp इटरेटर का इस्तेमाल करना (इसका सुझाव नहीं दिया जाता) 
var keywords = AdsApp.keywords()
    .withCondition('metrics.clicks > 50')
    .forDateRange('LAST_MONTH')
    .get();
while (keywords.hasNext()) {
  var keyword = keywords.next();
  var stats = keyword.getStatsFor('LAST_MONTH');
  Logger.log('Keyword: %s Impressions: %s ' +
      'Clicks: %s Cost: %s',
      keyword.getText(),
      stats.getImpressions(),
      stats.getClicks(),
      stats.getCost());
}

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

रिपोर्ट के बजाय खोज का इस्तेमाल करना

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

हमारा सुझाव है कि Google Ads API की नई रिपोर्टिंग की सभी सुविधाओं का फ़ायदा पाने के लिए, खोज सुविधा का इस्तेमाल करें.

AWQL के बजाय GAQL का इस्तेमाल करना

AWQL का इस्तेमाल अब भी रिपोर्ट क्वेरी और withCondition कॉल में किया जा सकता है. हालांकि, इसे ट्रांसलेशन लेयर के ज़रिए चलाया जाता है. यह लेयर, AWQL के साथ पूरी तरह से काम नहीं करती. अपनी क्वेरी पर पूरा कंट्रोल रखने के लिए, पक्का करें कि GAQL का इस्तेमाल किया जा रहा हो.

अगर आपको अपनी मौजूदा AWQL क्वेरी का अनुवाद करना है, तो हम आपकी मदद के लिए क्वेरी माइग्रेशन टूल उपलब्ध कराते हैं.

ज़रूरत से ज़्यादा लाइनें न चुनें

रिपोर्ट (और सिलेक्टर) को प्रोसेस करने की स्पीड, रिपोर्ट से मिलने वाली लाइनों की कुल संख्या पर निर्भर करती है. इससे कोई फ़र्क़ नहीं पड़ता कि आपने उन्हें दोहराया है या नहीं. इसका मतलब है कि आपको हमेशा खास फ़िल्टर इस्तेमाल करने चाहिए, ताकि नतीजों के सेट को कम से कम किया जा सके और आपके इस्तेमाल के उदाहरण से मैच किया जा सके.

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

कोडिंग का तरीका कोड स्निपेट
दो क्वेरी का इस्तेमाल करना (सुझाया गया) 
var adGroups = []
var report = AdsApp.search(
    'SELECT ad_group.name, ad_group.cpc_bid_micros' +
    ' FROM ad_group WHERE ad_group.cpc_bid_micros < 1000000');

while (report.hasNext()) {
  var row = report.next();
  adGroups.push(row.adGroup);
}
var report = AdsApp.search(
    'SELECT ad_group.name, ad_group.cpc_bid_micros' +
    ' FROM ad_group WHERE ad_group.cpc_bid_micros > 2000000');

while (report.hasNext()) {
  var row = report.next();
  adGroups.push(row.adGroup);
}
सामान्य क्वेरी से फ़िल्टर करना (इसका सुझाव नहीं दिया जाता) 
var adGroups = []
var report = AdsApp.search(
    'SELECT ad_group.name, ad_group.cpc_bid_micros' +
    ' FROM ad_group');

while (report.hasNext()) {
  var row = report.next();
  var cpcBidMicros = row.adGroup.cpcBidMicros;
  if (cpcBidMicros < 1000000 || cpcBidMicros > 2000000) {
    adGroups.push(row.adGroup);
  }
}

Google Ads मैनेजर खाते (एमसीसी) की स्क्रिप्ट

सीरियल एक्ज़ीक्यूशन के बजाय executeInParallel को प्राथमिकता दें

मैनेजर खातों के लिए स्क्रिप्ट लिखते समय, जहां हो सके वहां सीरियल एक्ज़ीक्यूशन के बजाय executeInParallel() का इस्तेमाल करें. executeInParallel() से आपकी स्क्रिप्ट को ज़्यादा प्रोसेसिंग टाइम (एक घंटे तक) मिलता है. साथ ही, हर प्रोसेस किए गए खाते के लिए 30 मिनट तक का समय मिलता है. हालांकि, सीरियल एक्ज़ीक्यूशन के लिए कुल 30 मिनट का समय मिलता है. ज़्यादा जानकारी के लिए, सीमाएं पेज देखें.

स्प्रेडशीट

स्प्रेडशीट अपडेट करते समय बैच ऑपरेशन का इस्तेमाल करना

स्प्रेडशीट अपडेट करते समय, एक बार में एक सेल अपडेट करने वाले तरीकों के बजाय, एक साथ कई कार्रवाइयां करने वाले तरीकों (उदाहरण के लिए, getRange()) का इस्तेमाल करें.

यहां दिए गए कोड स्निपेट पर विचार करें. यह स्प्रेडशीट पर फ़्रैक्टल पैटर्न जनरेट करता है.

कोडिंग का तरीका कोड स्निपेट
एक ही कॉल में सेल की रेंज अपडेट करना (इसका सुझाव दिया जाता है) 
var colors = new Array(100);
for (var y = 0; y < 100; y++) {
  xcoord = xmin;
  colors[y] = new Array(100);
  for (var x = 0; x < 100; x++) {
    colors[y][x] = getColor_(xcoord, ycoord);
    xcoord += xincrement;
  }
  ycoord -= yincrement;
}
sheet.getRange(1, 1, 100, 100).setBackgroundColors(colors);
एक बार में एक सेल अपडेट करना (इसका सुझाव नहीं दिया जाता) 
var cell = sheet.getRange('a1');
for (var y = 0; y < 100; y++) {
  xcoord = xmin;
  for (var x = 0; x < 100; x++) {
    var c = getColor_(xcoord, ycoord);
    cell.offset(y, x).setBackgroundColor(c);
    xcoord += xincrement;
  }
  ycoord -= yincrement;
  SpreadsheetApp.flush();
}

Google Sheets, वैल्यू को कैश मेमोरी में सेव करके दूसरे कोड स्निपेट को ऑप्टिमाइज़ करने की कोशिश करता है. हालांकि, एपीआई कॉल की संख्या ज़्यादा होने की वजह से, यह अब भी पहले स्निपेट की तुलना में खराब परफ़ॉर्म करता है.