สร้างโฆษณา Search แบบไดนามิก

หากต้องการตั้งค่าโฆษณา Search แบบไดนามิก (DSA) ด้วย Google Ads API ให้ทําตามขั้นตอนต่อไปนี้

1. สร้างแคมเปญและระบุโดเมน
2. สร้างกลุ่มโฆษณาสําหรับฟีเจอร์ที่เกี่ยวข้องกับ DSA
3. สร้าง DSA อย่างน้อย 1 รายการ
4. ระบุเกณฑ์อย่างน้อย 1 ข้อในการแสดง DSA ในแคมเปญ

สร้างแคมเปญ

หากต้องการแจ้งให้ Google Ads ทราบว่าคุณจะใช้ DSA กับแคมเปญ คุณจะต้องสร้าง Campaign ก่อนโดยตั้งค่าช่อง advertising_channel_type เป็น AdvertisingChannelType.SEARCH และระบุโดเมนที่ DSA จะทํางานด้วย ซึ่งทำได้โดยการตั้งค่าช่อง dynamic_search_ads_setting ของ Campaign โดยใช้ DynamicSearchAdsSetting

ตัวอย่างต่อไปนี้สร้างแคมเปญ DSA

Java

private static String addCampaign(
    GoogleAdsClient googleAdsClient, long customerId, String budgetResourceName) {
  // Creates the campaign.
  Campaign campaign =
      Campaign.newBuilder()
          .setName("Interplanetary Cruise #" + getPrintableDateTime())
          .setAdvertisingChannelType(AdvertisingChannelType.SEARCH)
          .setStatus(CampaignStatus.PAUSED)
          .setManualCpc(ManualCpc.newBuilder().build())
          .setCampaignBudget(budgetResourceName)
          // Enables the campaign for DSAs.
          .setDynamicSearchAdsSetting(
              DynamicSearchAdsSetting.newBuilder()
                  .setDomainName("example.com")
                  .setLanguageCode("en")
                  .build())
          .setStartDate(new DateTime().plusDays(1).toString("yyyyMMdd"))
          .setEndDate(new DateTime().plusDays(30).toString("yyyyMMdd"))
          .build();

  // Creates the operation.
  CampaignOperation operation = CampaignOperation.newBuilder().setCreate(campaign).build();

  // Creates the campaign service client.
  try (CampaignServiceClient campaignServiceClient =
      googleAdsClient.getLatestVersion().createCampaignServiceClient()) {
    // Adds the campaign.
    MutateCampaignsResponse response =
        campaignServiceClient.mutateCampaigns(
            Long.toString(customerId), ImmutableList.of(operation));

    String campaignResourceName = response.getResults(0).getResourceName();
    // Displays the results.
    System.out.printf("Added campaign with resource name '%s'.%n", campaignResourceName);
    return campaignResourceName;
  }
}
AddDynamicSearchAds.java
      

C#

private static string AddCampaign(GoogleAdsClient client, long customerId,
    string budgetResourceName)
{
    // Get the CampaignService.
    CampaignServiceClient campaignService = client.GetService(Services.V18.CampaignService);

    // Create the campaign.
    Campaign campaign = new Campaign()
    {
        Name = "Interplanetary Cruise #" + ExampleUtilities.GetRandomString(),
        AdvertisingChannelType = AdvertisingChannelType.Search,
        Status = CampaignStatus.Paused,
        ManualCpc = new ManualCpc(),
        CampaignBudget = budgetResourceName,

        // Enable the campaign for DSAs.
        DynamicSearchAdsSetting = new DynamicSearchAdsSetting()
        {
            DomainName = "example.com",
            LanguageCode = "en"
        },

        StartDate = DateTime.Now.AddDays(1).ToString("yyyyMMdd"),
        EndDate = DateTime.Now.AddDays(30).ToString("yyyyMMdd")
    };

    // Create the operation.
    CampaignOperation operation = new CampaignOperation()
    {
        Create = campaign
    };

    // Add the campaign.
    MutateCampaignsResponse response =
        campaignService.MutateCampaigns(customerId.ToString(),
            new CampaignOperation[] { operation });

    // Displays the result.
    string campaignResourceName = response.Results[0].ResourceName;
    Console.WriteLine($"Added campaign with resource name '{campaignResourceName}'.");
    return campaignResourceName;
}
AddDynamicSearchAds.cs
      

PHP

private static function createCampaign(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    string $campaignBudgetResourceName
) {
    $campaign = new Campaign([
        'name' => 'Interplanetary Cruise #' . Helper::getPrintableDatetime(),
        'advertising_channel_type' => AdvertisingChannelType::SEARCH,
        'status' => CampaignStatus::PAUSED,
        'manual_cpc' => new ManualCpc(),
        'campaign_budget' => $campaignBudgetResourceName,
        // Enables the campaign for DSAs.
        'dynamic_search_ads_setting' => new DynamicSearchAdsSetting([
            'domain_name' => 'example.com',
            'language_code' => 'en'
        ]),
        // Optional: Sets the start and end dates for the campaign, beginning one day from
        // now and ending a month from now.
        'start_date' => date('Ymd', strtotime('+1 day')),
        'end_date' => date('Ymd', strtotime('+1 month'))
    ]);

    // Creates a campaign operation.
    $campaignOperation = new CampaignOperation();
    $campaignOperation->setCreate($campaign);

    // Issues a mutate request to add campaigns.
    $campaignServiceClient = $googleAdsClient->getCampaignServiceClient();
    /** @var MutateCampaignsResponse $campaignResponse */
    $campaignResponse = $campaignServiceClient->mutateCampaigns(
        MutateCampaignsRequest::build($customerId, [$campaignOperation])
    );

    $campaignResourceName = $campaignResponse->getResults()[0]->getResourceName();
    printf("Added campaign named '%s'.%s", $campaignResourceName, PHP_EOL);

    return $campaignResourceName;
}
AddDynamicSearchAds.php
      

Python

def create_campaign(client, customer_id, budget_resource_name):
    """Creates a Dynamic Search Ad Campaign under the given customer ID.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID str.
        budget_resource_name: a resource_name str for a Budget

    Returns:
        A resource_name str for the newly created Campaign.
    """
    # Retrieve a new campaign operation object.
    campaign_operation = client.get_type("CampaignOperation")
    campaign = campaign_operation.create
    campaign.name = f"Interplanetary Cruise #{uuid4()}"
    campaign.advertising_channel_type = (
        client.enums.AdvertisingChannelTypeEnum.SEARCH
    )
    # Recommendation: Set the campaign to PAUSED when creating it to prevent the
    # ads from immediately serving. Set to ENABLED once you've added targeting
    # and the ads are ready to serve.
    campaign.status = client.enums.CampaignStatusEnum.PAUSED
    campaign.manual_cpc.enhanced_cpc_enabled = True
    campaign.campaign_budget = budget_resource_name
    # Required: Enable the campaign for DSAs by setting the campaign's dynamic
    # search ads setting domain name and language.
    campaign.dynamic_search_ads_setting.domain_name = "example.com"
    campaign.dynamic_search_ads_setting.language_code = "en"
    # Optional: Sets the start and end dates for the campaign, beginning one day
    # from now and ending a month from now.
    campaign.start_date = (datetime.now() + timedelta(days=1)).strftime(
        "%Y%m%d"
    )
    campaign.end_date = (datetime.now() + timedelta(days=30)).strftime("%Y%m%d")

    # Retrieve the campaign service.
    campaign_service = client.get_service("CampaignService")

    # Issues a mutate request to add campaign.
    response = campaign_service.mutate_campaigns(
        customer_id=customer_id, operations=[campaign_operation]
    )
    resource_name = response.results[0].resource_name

    print(f'Created campaign with resource_name: "{resource_name}"')
add_dynamic_search_ads.py
      

Ruby

def create_campaign(client, customer_id, budget_resource_name)
  campaign = client.resource.campaign do |c|
    c.name = "Interplanetary Cruise #{(Time.now.to_f * 1000).to_i}"

    c.advertising_channel_type = :SEARCH
    c.status = :PAUSED
    c.manual_cpc = client.resource.manual_cpc
    c.campaign_budget = budget_resource_name

    c.dynamic_search_ads_setting = client.resource.dynamic_search_ads_setting do |s|
      s.domain_name =  "example.com"
      s.language_code =  "en"
    end

    c.start_date = DateTime.parse((Date.today + 1).to_s).strftime('%Y%m%d')
    c.end_date = DateTime.parse(Date.today.next_year.to_s).strftime('%Y%m%d')
  end

  operation = client.operation.create_resource.campaign(campaign)

  response = client.service.campaign.mutate_campaigns(
    customer_id: customer_id,
    operations: [operation],
  )
  puts("Created campaign with ID: #{response.results.first.resource_name}")
  response.results.first.resource_name
end
add_dynamic_search_ads.rb
      

Perl

sub create_campaign {
  my ($api_client, $customer_id, $campaign_budget_resource_name) = @_;

  # Create a campaign.
  my $campaign = Google::Ads::GoogleAds::V18::Resources::Campaign->new({
      name                   => "Interplanetary Cruise #" . uniqid(),
      advertisingChannelType => SEARCH,
      status => Google::Ads::GoogleAds::V18::Enums::CampaignStatusEnum::PAUSED,
      manualCpc      => Google::Ads::GoogleAds::V18::Common::ManualCpc->new(),
      campaignBudget => $campaign_budget_resource_name,
      # Enable the campaign for DSAs.
      dynamicSearchAdsSetting =>
        Google::Ads::GoogleAds::V18::Resources::DynamicSearchAdsSetting->new({
          domainName   => "example.com",
          languageCode => "en"
        }
        ),
      # Optional: Set the start and end dates for the campaign, beginning one day from
      # now and ending a month from now.
      startDate => strftime("%Y%m%d", localtime(time + 60 * 60 * 24)),
      endDate   => strftime("%Y%m%d", localtime(time + 60 * 60 * 24 * 30)),
    });

  # Create a campaign operation.
  my $campaign_operation =
    Google::Ads::GoogleAds::V18::Services::CampaignService::CampaignOperation->
    new({create => $campaign});

  # Add the campaign.
  my $campaigns_response = $api_client->CampaignService()->mutate({
      customerId => $customer_id,
      operations => [$campaign_operation]});

  my $campaign_resource_name = $campaigns_response->{results}[0]{resourceName};

  printf "Created campaign '%s'.\n", $campaign_resource_name;

  return $campaign_resource_name;
}
add_dynamic_search_ads.pl
      

สร้างกลุ่มโฆษณา

หากต้องการใช้ฟีเจอร์ DSA คุณต้องสร้าง AdGroup โดยตั้งค่าช่อง type เป็น SEARCH_DYNAMIC_ADS กลุ่มโฆษณาประเภทนี้จะบังคับใช้ข้อจํากัดต่อไปนี้

• เพิ่มกลุ่มโฆษณาประเภทนี้ได้ในแคมเปญในเครือข่าย Search เท่านั้น
• ควรมีการตั้งค่า DynamicSearchAdsSetting ที่ถูกต้องที่ระดับแคมเปญ
• เพื่อให้เพิ่มกลุ่มโฆษณา ระบบจะแสดงข้อผิดพลาด AdGroupError.CANNOT_ADD_ADGROUP_OF_TYPE_DSA_TO_CAMPAIGN_WITHOUT_DSA_SETTING หากไม่มีการตั้งค่านี้
• ไม่อนุญาตให้ใช้คีย์เวิร์ดเชิงบวกในกลุ่มโฆษณาประเภทนี้ อนุญาตให้ใช้กลุ่มเป้าหมาย เป้าหมายโฆษณาแบบไดนามิก และคีย์เวิร์ดเชิงลบ
• เช่นเดียวกับกลุ่มโฆษณาทั้งหมด คุณจะเปลี่ยนแปลงฟิลด์ type ไม่ได้หลังจากสร้างแล้ว
• อนุญาตให้ใช้เฉพาะรูปแบบโฆษณาที่เกี่ยวข้องกับ DSA ในกลุ่มโฆษณานี้

ตัวอย่างโค้ดด้านล่างแสดงวิธีสร้างกลุ่มโฆษณา SEARCH_DYNAMIC_ADS

Java

private static String addAdGroup(
    GoogleAdsClient googleAdsClient, long customerId, String campaignResourceName) {
  // Creates the ad group.
  AdGroup adGroup =
      AdGroup.newBuilder()
          .setName("Earth to Mars Cruises #" + getPrintableDateTime())
          .setCampaign(campaignResourceName)
          .setType(AdGroupType.SEARCH_DYNAMIC_ADS)
          .setStatus(AdGroupStatus.PAUSED)
          .setTrackingUrlTemplate("http://tracker.examples.com/traveltracker/{escapedlpurl}")
          .setCpcBidMicros(50_000)
          .build();

  // Creates the operation.
  AdGroupOperation operation = AdGroupOperation.newBuilder().setCreate(adGroup).build();

  // Creates the ad group service client.
  try (AdGroupServiceClient adGroupServiceClient =
      googleAdsClient.getLatestVersion().createAdGroupServiceClient()) {
    MutateAdGroupsResponse response =
        adGroupServiceClient.mutateAdGroups(
            Long.toString(customerId), ImmutableList.of(operation));
    String adGroupResourceName = response.getResults(0).getResourceName();
    // Displays the results.
    System.out.printf("Added ad group with resource name '%s'.%n", adGroupResourceName);
    return adGroupResourceName;
  }
}
AddDynamicSearchAds.java
      

C#

private static string AddAdGroup(GoogleAdsClient client, long customerId,
    string campaignResourceName)
{
    // Get the AdGroupService.
    AdGroupServiceClient adGroupService = client.GetService(Services.V18.AdGroupService);

    // Create the ad group.
    AdGroup adGroup = new AdGroup()
    {
        Name = "Earth to Mars Cruises #" + ExampleUtilities.GetRandomString(),
        Campaign = campaignResourceName,
        Type = AdGroupType.SearchDynamicAds,
        Status = AdGroupStatus.Paused,
        TrackingUrlTemplate = "http://tracker.examples.com/traveltracker/{escapedlpurl}",
        CpcBidMicros = 50_000
    };

    // Create the operation.
    AdGroupOperation operation = new AdGroupOperation()
    {
        Create = adGroup
    };

    // Add the ad group.
    MutateAdGroupsResponse response =
        adGroupService.MutateAdGroups(customerId.ToString(),
            new AdGroupOperation[] { operation });

    // Display the results.
    string adGroupResourceName = response.Results[0].ResourceName;
    Console.WriteLine($"Added ad group with resource name '{adGroupResourceName}'.");

    return adGroupResourceName;
}
AddDynamicSearchAds.cs
      

PHP

private static function createAdGroup(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    string $campaignResourceName
) {
    // Constructs an ad group and sets an optional CPC value.
    $adGroup = new AdGroup([
        'name' => 'Earth to Mars Cruises #' . Helper::getPrintableDatetime(),
        'campaign' => $campaignResourceName,
        'status' => AdGroupStatus::PAUSED,
        'type' => AdGroupType::SEARCH_DYNAMIC_ADS,
        'tracking_url_template' => 'http://tracker.examples.com/traveltracker/{escapedlpurl}',
        'cpc_bid_micros' => 10000000
    ]);

    // Creates an ad group operation.
    $adGroupOperation = new AdGroupOperation();
    $adGroupOperation->setCreate($adGroup);

    // Issues a mutate request to add the ad groups.
    $adGroupServiceClient = $googleAdsClient->getAdGroupServiceClient();
    /** @var MutateAdGroupsResponse $adGroupResponse */
    $adGroupResponse = $adGroupServiceClient->mutateAdGroups(
        MutateAdGroupsRequest::build($customerId, [$adGroupOperation])
    );

    $adGroupResourceName = $adGroupResponse->getResults()[0]->getResourceName();
    printf("Added ad group named '%s'.%s", $adGroupResourceName, PHP_EOL);

    return $adGroupResourceName;
}
AddDynamicSearchAds.php
      

Python

def create_ad_group(client, customer_id, campaign_resource_name):
    """Creates a Dynamic Search Ad Group under the given Campaign.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID str.
        campaign_resource_name: a resource_name str for a Campaign.

    Returns:
        A resource_name str for the newly created Ad Group.
    """
    # Retrieve a new ad group operation object.
    ad_group_operation = client.get_type("AdGroupOperation")
    # Create an ad group.
    ad_group = ad_group_operation.create
    # Required: set the ad group's type to Dynamic Search Ads.
    ad_group.type_ = client.enums.AdGroupTypeEnum.SEARCH_DYNAMIC_ADS
    ad_group.name = f"Earth to Mars Cruises {uuid4()}"
    ad_group.campaign = campaign_resource_name
    ad_group.status = client.enums.AdGroupStatusEnum.PAUSED
    # Recommended: set a tracking URL template for your ad group if you want to
    # use URL tracking software.
    ad_group.tracking_url_template = (
        "http://tracker.example.com/traveltracker/{escapedlpurl}"
    )
    # Optional: Set the ad group bid value.
    ad_group.cpc_bid_micros = 10000000

    # Retrieve the ad group service.
    ad_group_service = client.get_service("AdGroupService")

    # Issues a mutate request to add the ad group.
    response = ad_group_service.mutate_ad_groups(
        customer_id=customer_id, operations=[ad_group_operation]
    )
    resource_name = response.results[0].resource_name

    print(f'Created Ad Group with resource_name: "{resource_name}"')
add_dynamic_search_ads.py
      

Ruby

def create_ad_group(client, customer_id, campaign_resource_name)
  ad_group = client.resource.ad_group do |ag|
    ag.type = :SEARCH_DYNAMIC_ADS
    ag.name = "Earth to Mars Cruises #{(Time.now.to_f * 1000).to_i}"

    ag.campaign =  campaign_resource_name

    ag.status = :PAUSED
    ag.tracking_url_template = "http://tracker.example.com/traveltracker/{escapedlpurl}"

    ag.cpc_bid_micros = 3_000_000
  end

  operation = client.operation.create_resource.ad_group(ad_group)

  response = client.service.ad_group.mutate_ad_groups(
    customer_id: customer_id,
    operations: [operation],
  )

  puts("Created ad group with ID: #{response.results.first.resource_name}")
  response.results.first.resource_name
end
add_dynamic_search_ads.rb
      

Perl

sub create_ad_group {
  my ($api_client, $customer_id, $campaign_resource_name) = @_;

  # Construct an ad group and set an optional CPC value.
  my $ad_group = Google::Ads::GoogleAds::V18::Resources::AdGroup->new({
    name     => "Earth to Mars Cruises #" . uniqid(),
    campaign => $campaign_resource_name,
    status   => Google::Ads::GoogleAds::V18::Enums::AdGroupStatusEnum::PAUSED,
    type     => SEARCH_DYNAMIC_ADS,
    trackingUrlTemplate =>
      "http://tracker.examples.com/traveltracker/{escapedlpurl}",
    cpcBidMicros => 3000000
  });

  # Create an ad group operation.
  my $ad_group_operation =
    Google::Ads::GoogleAds::V18::Services::AdGroupService::AdGroupOperation->
    new({create => $ad_group});

  # Add the ad group.
  my $ad_groups_response = $api_client->AdGroupService()->mutate({
      customerId => $customer_id,
      operations => [$ad_group_operation]});

  my $ad_group_resource_name = $ad_groups_response->{results}[0]{resourceName};

  printf "Created ad group '%s'.\n", $ad_group_resource_name;

  return $ad_group_resource_name;
}
add_dynamic_search_ads.pl
      

สร้าง DSA

หากต้องการสร้าง DSA จริง คุณต้องใช้ออบเจ็กต์ ExpandedDynamicSearchAdInfo และตั้งค่าช่องต่อไปนี้

• ต้องระบุ: description
• ไม่บังคับ: description2

โฆษณานี้จะมีบรรทัดแรก, URL ที่แสดง และ URL สุดท้ายที่สร้างขึ้นโดยอัตโนมัติ ณ เวลาแสดงตามข้อมูลที่เจาะจงชื่อโดเมนซึ่งได้จากDynamicSearchAdsSettingที่ตั้งค่าไว้ที่ระดับแคมเปญ

Java

private static void addExpandedDSA(
    GoogleAdsClient googleAdsClient, long customerId, String adGroupResourceName) {
  // Creates an ad group ad.
  AdGroupAd adGroupAd =
      AdGroupAd.newBuilder()
          .setAdGroup(adGroupResourceName)
          .setStatus(AdGroupAdStatus.PAUSED)
          // Sets the ad as an expanded dynamic search ad
          .setAd(
              Ad.newBuilder()
                  .setExpandedDynamicSearchAd(
                      ExpandedDynamicSearchAdInfo.newBuilder()
                          .setDescription("Buy tickets now!")
                          .build())
                  .build())
          .build();

  // Creates the operation.
  AdGroupAdOperation operation = AdGroupAdOperation.newBuilder().setCreate(adGroupAd).build();

  // Creates the ad group ad service client.
  try (AdGroupAdServiceClient adGroupAdServiceClient =
      googleAdsClient.getLatestVersion().createAdGroupAdServiceClient()) {
    // Adds the dynamic search ad.
    MutateAdGroupAdsResponse response =
        adGroupAdServiceClient.mutateAdGroupAds(
            Long.toString(customerId), ImmutableList.of(operation));
    // Displays the response.
    System.out.printf(
        "Added ad group ad with resource name '%s'.%n", response.getResults(0).getResourceName());
  }
}
AddDynamicSearchAds.java
      

C#

private static void AddExpandedDSA(GoogleAdsClient client, long customerId,
    string adGroupResourceName)
{
    // Get the AdGroupAdService.
    AdGroupAdServiceClient adGroupAdService =
        client.GetService(Services.V18.AdGroupAdService);

    // Create an ad group ad.
    AdGroupAd adGroupAd = new AdGroupAd()
    {
        AdGroup = adGroupResourceName,
        Status = AdGroupAdStatus.Paused,

        // Set the ad as an expanded dynamic search ad.
        Ad = new Ad()
        {
            ExpandedDynamicSearchAd = new ExpandedDynamicSearchAdInfo()
            {
                Description = "Buy tickets now!"
            }
        }
    };

    // Create the operation.
    AdGroupAdOperation operation = new AdGroupAdOperation()
    {
        Create = adGroupAd
    };

    // Add the dynamic search ad.
    MutateAdGroupAdsResponse response = adGroupAdService.MutateAdGroupAds(
        customerId.ToString(), new AdGroupAdOperation[] { operation });

    // Display the response.
    Console.WriteLine($"Added ad group ad with resource name " +
        $"'{response.Results[0].ResourceName}'.");
}
AddDynamicSearchAds.cs
      

PHP

private static function createExpandedDSA(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    string $adGroupResourceName
) {
    $adGroupAd = new AdGroupAd([
        'ad_group' => $adGroupResourceName,
        'status' => AdGroupAdStatus::PAUSED,
        'ad' => new Ad([
            'expanded_dynamic_search_ad' => new ExpandedDynamicSearchAdInfo([
                'description' => 'Buy tickets now!'
            ])
        ])
    ]);

    $adGroupAdOperation = new AdGroupAdOperation();
    $adGroupAdOperation->setCreate($adGroupAd);

    // Issues a mutate request to add the ad group ads.
    $adGroupAdServiceClient = $googleAdsClient->getAdGroupAdServiceClient();
    /** @var MutateAdGroupAdsResponse $adGroupAdResponse */
    $adGroupAdResponse = $adGroupAdServiceClient->mutateAdGroupAds(
        MutateAdGroupAdsRequest::build($customerId, [$adGroupAdOperation])
    );

    $adGroupAdResourceName = $adGroupAdResponse->getResults()[0]->getResourceName();
    printf("Added ad group ad named '%s'.%s", $adGroupAdResourceName, PHP_EOL);

    return $adGroupAdResourceName;
}
AddDynamicSearchAds.php
      

Python

def create_expanded_dsa(client, customer_id, ad_group_resource_name):
    """Creates a dynamic search ad under the given ad group.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID str.
        ad_group_resource_name: a resource_name str for an Ad Group.
    """
    # Retrieve a new ad group ad operation object.
    ad_group_ad_operation = client.get_type("AdGroupAdOperation")
    # Create and expanded dynamic search ad. This ad will have its headline,
    # display URL and final URL auto-generated at serving time according to
    # domain name specific information provided by DynamicSearchAdSetting at
    # the campaign level.
    ad_group_ad = ad_group_ad_operation.create
    # Optional: set the ad status.
    ad_group_ad.status = client.enums.AdGroupAdStatusEnum.PAUSED
    # Set the ad description.
    ad_group_ad.ad.expanded_dynamic_search_ad.description = "Buy tickets now!"
    ad_group_ad.ad_group = ad_group_resource_name

    # Retrieve the ad group ad service.
    ad_group_ad_service = client.get_service("AdGroupAdService")

    # Submit the ad group ad operation to add the ad group ad.
    response = ad_group_ad_service.mutate_ad_group_ads(
        customer_id=customer_id, operations=[ad_group_ad_operation]
    )
    resource_name = response.results[0].resource_name

    print(f'Created Ad Group Ad with resource_name: "{resource_name}"')
add_dynamic_search_ads.py
      

Ruby

def create_expanded_dsa(client, customer_id, ad_group_resource_name)
  ad_group_ad = client.resource.ad_group_ad do |aga|
    aga.status = :PAUSED
    aga.ad = client.resource.ad do |ad|
      ad.expanded_dynamic_search_ad = client.resource.expanded_dynamic_search_ad_info do |info|
        info.description = "Buy tickets now!"
      end
    end

    aga.ad_group = ad_group_resource_name
  end

  operation = client.operation.create_resource.ad_group_ad(ad_group_ad)

  response = client.service.ad_group_ad.mutate_ad_group_ads(
    customer_id: customer_id,
    operations: [operation],
  )
  puts("Created ad group ad with ID: #{response.results.first.resource_name}")
end
add_dynamic_search_ads.rb
      

Perl

sub create_expanded_dsa {
  my ($api_client, $customer_id, $ad_group_resource_name) = @_;

  # Create an ad group ad.
  my $ad_group_ad = Google::Ads::GoogleAds::V18::Resources::AdGroupAd->new({
      adGroup => $ad_group_resource_name,
      status => Google::Ads::GoogleAds::V18::Enums::AdGroupAdStatusEnum::PAUSED,
      ad     => Google::Ads::GoogleAds::V18::Resources::Ad->new({
          expandedDynamicSearchAd =>
            Google::Ads::GoogleAds::V18::Common::ExpandedDynamicSearchAdInfo->
            new({
              description => "Buy tickets now!"
            })})});

  # Create an ad group ad operation.
  my $ad_group_ad_operation =
    Google::Ads::GoogleAds::V18::Services::AdGroupAdService::AdGroupAdOperation
    ->new({create => $ad_group_ad});

  # Add the ad group ad.
  my $ad_group_ads_response = $api_client->AdGroupAdService()->mutate({
      customerId => $customer_id,
      operations => [$ad_group_ad_operation]});

  my $ad_group_ad_resource_name =
    $ad_group_ads_response->{results}[0]{resourceName};

  printf "Created ad group ad '%s'.\n", $ad_group_ad_resource_name;

  return $ad_group_ad_resource_name;
}
add_dynamic_search_ads.pl
      

Google Ads จะคํานวณช่อง final_urls เมื่อสร้าง DSA คุณจึงตั้งค่าช่องนี้ไม่ได้เมื่อสร้าง DSA หากต้องการใช้ซอฟต์แวร์การติดตาม URL คุณสามารถระบุพารามิเตอร์การติดตามหรือการเปลี่ยนเส้นทางเพิ่มเติมที่ต้องการได้โดยใช้ช่อง tracking_url_template เมื่อระบุช่องนี้ คุณต้องใส่พารามิเตอร์อย่างใดอย่างหนึ่งต่อไปนี้เพื่อให้ Google Ads ใส่ URL สุดท้ายที่ตรงกัน

พารามิเตอร์	คำอธิบาย
{unescapedlpurl}	URL ของหน้า Landing Page ที่ไม่มีการหลีกค่าบ่ายหน้า - หากคุณต้องการเพิ่มข้อความต่อท้าย เช่น {unescapedlpurl}?dsa=true
{escapedlpurl}	URL ของหน้า Landing Page ที่ใช้อักขระหลีก (เข้ารหัส URL) หากคุณต้องการเปลี่ยนเส้นทางไปยังเครื่องมือติดตาม เช่น http://tracking.com/lp={escapedurl}
{lpurlpath}	เฉพาะพารามิเตอร์เส้นทางและพารามิเตอร์การค้นหาจาก URL ที่คำนวณแล้ว เช่น http://tracking.com.com/track/{lpurlpath}
{lpurl}	เข้ารหัส ? และ = ของ URL ของหน้า Landing Page และลงท้ายด้วยคำค้นหา หากพบที่จุดเริ่มต้นของช่อง tracking_url_template ระบบจะแทนที่ค่า {unescapedurl} แทนค่านั้น เช่น http://tracking.com/redir.php?tracking=xyz&url={lpurl}

เช่น

Java

dsa.setTrackingUrlTemplate(
    StringValue.of("http://example.com/traveltracker/{escapedlpurl}"));

ระบุเกณฑ์สําหรับ DSA

สุดท้าย คุณจะต้องตั้งค่าเกณฑ์บางอย่างเพื่อทริกเกอร์การแสดง DSA ซึ่งทำได้โดยใช้ช่อง webpage ของ AdGroupCriterion ฟิลด์ webpage นี้ได้รับการตั้งค่าให้เป็นออบเจ็กต์ WebpageInfo ซึ่งอนุญาตให้มี conditions ได้ 1-3 รายการ

conditions เหล่านี้คืออินสแตนซ์ WebpageConditionInfo ที่ให้คุณระบุสิ่งที่จะกรองหรือค้นหาภายในโดเมนที่ระบุไว้ก่อนหน้านี้ในการตั้งค่าแคมเปญ รายการที่คุณกรองภายในโดเมนได้มีอยู่ 5 รายการดังนี้

WebpageConditionOperand	คำอธิบาย
URL	สตริงที่ตรงกับ URL บางส่วนของหน้าเว็บ
CATEGORY	สตริงที่มีหมวดหมู่ที่จะจับคู่ได้อย่างถูกต้อง
PAGE_TITLE	สตริงที่ตรงกับชื่อหน้าบางส่วน
PAGE_CONTENT	สตริงที่ตรงกับเนื้อหาบางส่วนภายในหน้าที่ได้รับการจัดทำดัชนีที่กำหนด
CUSTOM_LABEL	สตริงที่ตรงกับเงื่อนไขการกําหนดเป้าหมายป้ายกํากับที่กําหนดเองของหน้าเว็บ ดูกําหนดเป้าหมาย URL ของฟีดหน้าเว็บโดยใช้ป้ายกํากับที่กําหนดเอง

เช่น คุณอาจสร้างเกณฑ์หน้าเว็บที่กำหนดเป้าหมายไปยังทุกสิ่งที่อยู่ใน/childrenสาขาของเว็บไซต์วันหยุด (เงื่อนไข URL) แต่เฉพาะหน้าเว็บที่มี "ข้อเสนอพิเศษ" ในชื่อ (เงื่อนไข PAGE_TITLE)

การค้นพบหมวดหมู่ของเว็บไซต์

คุณสามารถดึงข้อมูลและกรองรายการ DomainCategory ที่ Google คิดว่าเกี่ยวข้องกับเว็บไซต์ของคุณได้โดยเลือกฟิลด์ของแหล่งข้อมูล domain_category ในการค้นหา GAQL

การค้นหา GAQL ต่อไปนี้จะดึงข้อมูลรายการหมวดหมู่โดเมนสําหรับเว็บไซต์และแคมเปญที่เฉพาะเจาะจง โดยกรองตามรหัส

SELECT
  domain_category.category,
  domain_category.language_code,
  domain_category.recommended_cpc_bid_micros
FROM domain_category
WHERE domain_category.domain = 'example.com'
  AND campaign.id = campaign_id

การยกเว้นชิ้นส่วนของเว็บไซต์

นอกจากนี้ คุณยังใช้ AdGroupCriterionService เพื่อตั้งค่าเกณฑ์หน้าเว็บเชิงลบได้ด้วย เช่น ใช้ข้อมูลนี้เพื่อยกเว้นหน้าเว็บที่มีชื่อเฉพาะซึ่งต้องการจัดการกับแคมเปญหรือกลุ่มโฆษณาอื่น

เกณฑ์อื่นๆ

แคมเปญและกลุ่มโฆษณา DSA ไม่ได้จํากัดไว้เฉพาะเกณฑ์หน้าเว็บ คุณสามารถใช้เกณฑ์ประเภทอื่นๆ ต่อไปเพื่อปรับแต่งและปรับปรุงคุณภาพของโฆษณาได้ คุณควรมีความรอบคอบในการใช้เกณฑ์เพิ่มเติม อย่างไรก็ตาม การเพิ่มเกณฑ์มากเกินไปอาจทำให้ประสิทธิภาพของการกำหนดเป้าหมายอัตโนมัติของ DSA ลดลง