मांग बढ़ाने में मदद करने वाला विज्ञापन

मांग बढ़ाने में मदद करने वाले कैंपेन की मदद से, Google के अलग-अलग विज़ुअल प्लैटफ़ॉर्म पर मौजूद लोगों को अपने ब्रैंड की कहानी बताई जा सकती है. जैसे: YouTube (इसमें Shorts भी शामिल है), डिस्कवर, Gmail, Google Maps, और Google Display Network. मांग बढ़ाने में मदद करने वाले कैंपेन की मदद से, अलग-अलग टचपॉइंट पर मौजूद ग्राहकों तक पहुंचा जा सकता है. साथ ही, Google के एआई का इस्तेमाल करके, काम की ऑडियंस को क्रिएटिव दिखाए जा सकते हैं. इसके अलावा, फ़नल में बिडिंग को ऑप्टिमाइज़ किया जा सकता है. साथ ही, आपको अपने कैंपेन की ऐसेट और प्लेसमेंट को पूरी तरह से कंट्रोल करने का विकल्प मिलता है.

एपीआई के मुख्य संसाधन

Google Ads API में मांग बढ़ाने में मदद करने वाले कैंपेन मैनेज करते समय, इन संसाधनों और सेटिंग का इस्तेमाल किया जाता है:

प्राइमरी रिसॉर्स मांग बढ़ाने में मदद करने वाले कैंपेन के मुख्य फ़ील्ड और सेटिंग
CampaignBudget explicitly_shared = false; इसमें रोज़ का बजट (amount_micros) या कस्टम कुल बजट (total_amount_micros के साथ period = CUSTOM_PERIOD) सेट किया जा सकता है.
Campaign advertising_channel_type = DEMAND_GEN; बिडिंग की रणनीति (maximize_conversions, maximize_conversion_value, target_cpa, target_roas, target_spend या target_cpc); प्रॉडक्ट फ़ीड के लिए shopping_setting ज़रूरी नहीं है.
AdGroup audience_setting.use_audience_grouped; demand_gen_ad_group_settings.channel_controls (YouTube, डिस्कवर, Gmail, Maps, डिसप्ले).
AdGroupCriterion audience (AudienceInfo), location, language, और listing_group ( ListingGroupInfo).
AdGroupAd & Asset ad.demand_gen_multi_asset_ad, ad.demand_gen_carousel_ad, ad.demand_gen_video_responsive_ad या ad.demand_gen_product_ad.

विज्ञापन की मांग बढ़ाने में मदद करने वाला कैंपेन बनाना

हमारा सुझाव है कि बजट, कैंपेन, विज्ञापन ग्रुप, ऐसेट, और मांग बढ़ाने में मदद करने वाले विज्ञापन को एक ही GoogleAdsService.Mutate अनुरोध में बनाएं. इसके लिए, नेगेटिव टेंपररी रिसॉर्स आईडी का इस्तेमाल करें, ताकि एक-दूसरे पर निर्भर रिसॉर्स एक-दूसरे को रेफ़रंस कर सकें:

Java

// The below methods create and return MutateOperations that we later provide to
// the GoogleAdsService.Mutate method in order to create the entities in a single
// request. Since the entities for a Demand Gen campaign are closely tied to one-another
// it's considered a best practice to create them in a single Mutate request; the
// entities will either all complete successfully or fail entirely, leaving no
// orphaned entities. See:
// https://developers.google.com/google-ads/api/docs/mutating/overview
List<MutateOperation> operations = new ArrayList<>();
// A utility to create temporary IDs for the resources.
AtomicLong tempId = new AtomicLong(-1);

// Creates a new campaign budget operation and adds it to the list of operations.
String budgetResourceName = ResourceNames.campaignBudget(customerId, tempId.getAndDecrement());
operations.add(
    MutateOperation.newBuilder()
        .setCampaignBudgetOperation(createCampaignBudgetOperation(budgetResourceName))
        .build());

// Creates a new campaign operation and adds it to the list of operations.
String campaignResourceName = ResourceNames.campaign(customerId, tempId.getAndDecrement());
operations.add(
    MutateOperation.newBuilder()
        .setCampaignOperation(
            createDemandGenCampaignOperation(campaignResourceName, budgetResourceName))
        .build());

// Creates a new ad group operation and adds it to the list of operations.
String adGroupResourceName = ResourceNames.adGroup(customerId, tempId.getAndDecrement());
operations.add(
    MutateOperation.newBuilder()
        .setAdGroupOperation(
            createDemandGenAdGroupOperation(adGroupResourceName, campaignResourceName))
        .build());

// Creates the asset operations for the ad.
Map<String, String> assetResourceNames = new HashMap<>();
operations.addAll(
    createAssetOperations(customerId, youTubeVideoId, tempId, assetResourceNames));

// Creates a new ad group ad operation and adds it to the list of operations.
operations.add(
    MutateOperation.newBuilder()
        .setAdGroupAdOperation(
            createDemandGenAdGroupAdOperation(adGroupResourceName, assetResourceNames))
        .build());

// Creates the service client.
try (GoogleAdsServiceClient googleAdsServiceClient =
    googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
  // Sends the mutate request.
  MutateGoogleAdsResponse response =
      googleAdsServiceClient.mutate(String.valueOf(customerId), operations);

  // Prints the results.
  System.out.printf(
      "Created campaign with resource name: %s%n",
      response
          .getMutateOperationResponses(1)
          .getCampaignResult()
          .getResourceName());
  System.out.printf(
      "Created ad group with resource name: %s%n",
      response
          .getMutateOperationResponses(2)
          .getAdGroupResult()
          .getResourceName());
  for (Map.Entry<String, String> entry : assetResourceNames.entrySet()) {
    System.out.printf(
        "Created asset with temporary resource name '%s' and final resource name '%s'.%n",
        entry.getValue(),
        response
            .getMutateOperationResponses(
                operations.indexOf(getOperationForAsset(operations, entry.getValue())))
            .getAssetResult()
            .getResourceName());
  }
  System.out.printf(
      "Created ad group ad with resource name: %s%n",
      response
          .getMutateOperationResponses(operations.size() - 1)
          .getAdGroupAdResult()
          .getResourceName());
}

C#

// The below methods create and return MutateOperations that we later provide to
// the GoogleAdsService.Mutate method in order to create the entities in a single
// request. Since the entities for a Demand Gen campaign are closely tied to one-another
// it's considered a best practice to create them in a single Mutate request; the
// entities will either all complete successfully or fail entirely, leaving no
// orphaned entities. See:
// https://developers.google.com/google-ads/api/docs/mutating/overview
MutateOperation campaignBudgetOperation =
    CreateCampaignBudgetOperation(budgetResourceName);
MutateOperation campaignOperation =
    CreateDemandGenCampaignOperation(campaignResourceName, budgetResourceName);
MutateOperation adGroupOperation =
    CreateAdGroupOperation(adGroupResourceName, campaignResourceName);

// Send the operations in a single mutate request.
MutateGoogleAdsRequest mutateGoogleAdsRequest = new MutateGoogleAdsRequest
{
    CustomerId = customerId.ToString()
};
// It's important to create these entities in this order because they depend on
// each other, for example the ad group depends on the
// campaign, and the ad group ad depends on the ad group.
mutateGoogleAdsRequest.MutateOperations.Add(campaignBudgetOperation);
mutateGoogleAdsRequest.MutateOperations.Add(campaignOperation);
mutateGoogleAdsRequest.MutateOperations.Add(adGroupOperation);

mutateGoogleAdsRequest.MutateOperations.AddRange(
    CreateAssetOperations(
        videoAssetResourceName,
        videoId,
        logoResourceName,
        client.Config
    )
);

mutateGoogleAdsRequest.MutateOperations.Add(
    CreateDemandGenAdOperation(
        adGroupResourceName,
        videoAssetResourceName,
        logoResourceName
    )
);

MutateGoogleAdsResponse response =
        googleAdsServiceClient.Mutate(mutateGoogleAdsRequest);

PHP

This example is not yet available in PHP; you can take a look at the other languages.

Python

# The below methods create and return MutateOperations that we later provide
# to the GoogleAdsService.Mutate method in order to create the entities in a
# single request. Since the entities for a Demand Gen campaign are closely
# tied to one-another it's considered a best practice to create them in a
# single Mutate request; the entities will either all complete successfully
# or fail entirely, leaving no orphaned entities. See:
# https://developers.google.com/google-ads/api/docs/mutating/overview
mutate_operations: List[MutateOperation] = [
    # It's important to create these entities in this order because they
    # depend on each other, for example the ad group depends on the
    # campaign, and the ad group ad depends on the ad group.
    create_campaign_budget_operation(client, budget_resource_name),
    create_demand_gen_campaign_operation(
        client, campaign_resource_name, budget_resource_name
    ),
    create_ad_group_operation(
        client, ad_group_resource_name, campaign_resource_name
    ),
    *create_asset_operations(  # Use iterable unpacking
        client,
        video_asset_resource_name,
        video_id,
        logo_asset_resource_name,
    ),
    create_demand_gen_ad_operation(
        client,
        ad_group_resource_name,
        video_asset_resource_name,
        logo_asset_resource_name,
    ),
]

# Send the operations in a single mutate request.
googleads_service.mutate(
    customer_id=customer_id, mutate_operations=mutate_operations
)

Ruby

operations = []

operations << client.operation.mutate do |m|
  m.campaign_budget_operation = create_campaign_budget_operation(client, budget_resource_name)
end

operations << client.operation.mutate do |m|
  m.campaign_operation = create_demand_gen_campaign_operation(client, campaign_resource_name, budget_resource_name)
end

operations << client.operation.mutate do |m|
  m.ad_group_operation = create_ad_group_operation(client, ad_group_resource_name, campaign_resource_name)
end

operations += create_asset_operations(client, video_asset_resource_name, video_id, logo_asset_resource_name).map do |asset_op|
  client.operation.mutate do |m|
    m.asset_operation = asset_op
  end
end

operations << client.operation.mutate do |m|
  m.ad_group_ad_operation = create_demand_gen_ad_operation(client, ad_group_resource_name, video_asset_resource_name, logo_asset_resource_name)
end

response = client.service.google_ads.mutate(
  customer_id: customer_id,
  mutate_operations: operations,
)

Perl

This example is not yet available in Perl; you can take a look at the other languages.

curl

बजट, बिडिंग की रणनीतियों, और विज्ञापन फ़ॉर्मैट के बारे में सिलसिलेवार निर्देश पाने के लिए, मांग बढ़ाने में मदद करने वाला कैंपेन बनाना लेख पढ़ें.

मांग बढ़ाने में मदद करने वाले कैंपेन के बारे में क्वेरी करना

नेटवर्क और YouTube प्लैटफ़ॉर्म के हिसाब से सेगमेंट किए गए, मांग बढ़ाने में मदद करने वाले कैंपेन के एट्रिब्यूट और परफ़ॉर्मेंस मेट्रिक वापस पाने के लिए, GoogleAdsService.SearchStream का इस्तेमाल करें. इसके लिए, segments.ad_network_type और segments.ad_sub_network_type को एक साथ चुना जाना चाहिए:

SELECT
  campaign.id,
  campaign.name,
  campaign.status,
  campaign.bidding_strategy_type,
  segments.ad_network_type,
  segments.ad_sub_network_type,
  metrics.impressions,
  metrics.clicks,
  metrics.conversions,
  metrics.cost_micros
FROM campaign
WHERE campaign.advertising_channel_type = DEMAND_GEN
  AND segments.date DURING LAST_30_DAYS

विज्ञापन-लेवल, ऐसेट-लेवल, और कन्वर्ज़न ब्रेकडाउन क्वेरी के लिए, मांग बढ़ाने में मदद करने वाले कैंपेन की रिपोर्टिंग देखें.

अगले चरण

आगे बढ़ें
कैंपेन बनाएं