יצירת מודעות דינמיות לרשת החיפוש

כך מגדירים מודעות דינמיות לרשת החיפוש באמצעות Google Ads API:

1. יוצרים קמפיין ומציינים את הדומיין שלו.
2. יוצרים קבוצת מודעות שכוללת תכונות שקשורות למודעות דינמיות לרשת החיפוש.
3. יוצרים מודעה אחת או יותר של מודעות דינמיות לרשת החיפוש.
4. מציינים קריטריון אחד או יותר להצגת המודעות הדינמיות לרשת החיפוש בקמפיין.

יצירת הקמפיין

כדי להודיע ל-Google Ads שבכוונתכם להשתמש במודעות דינמיות לרשת החיפוש בקמפיין, קודם צריך ליצור Campaign בשדה advertising_channel_type שמוגדר כ-AdvertisingChannelType.SEARCH. בנוסף, ציינו דומיין שבו יפעלו המודעות הדינמיות לרשת החיפוש. כדי לעשות זאת, מגדירים את השדה dynamic_search_ads_setting ב-Campaign באמצעות DynamicSearchAdsSetting.

הדוגמה הבאה יוצרת קמפיין של מודעות דינמיות לרשת החיפוש.

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.V16.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::V16::Resources::Campaign->new({
      name                   => "Interplanetary Cruise #" . uniqid(),
      advertisingChannelType => SEARCH,
      status => Google::Ads::GoogleAds::V16::Enums::CampaignStatusEnum::PAUSED,
      manualCpc      => Google::Ads::GoogleAds::V16::Common::ManualCpc->new(),
      campaignBudget => $campaign_budget_resource_name,
      # Enable the campaign for DSAs.
      dynamicSearchAdsSetting =>
        Google::Ads::GoogleAds::V16::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::V16::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
      

יצירת קבוצת המודעות

כדי להשתמש בתכונות של מודעות דינמיות לרשת החיפוש, צריך ליצור AdGroup בשדה type שמוגדר כ-SEARCH_DYNAMIC_ADS. הסוג הזה של קבוצת מודעות אוכף את ההגבלות הבאות:

• אפשר להוסיף את סוג קבוצת המודעות הזה רק לקמפיינים לרשת החיפוש.
• צריך להגדיר DynamicSearchAdsSetting חוקי ברמת הקמפיין
• לקבוצת המודעות שתתווסף. אם ההגדרה הזו חסרה, תוצג הודעת שגיאה של AdGroupError.CANNOT_ADD_ADGROUP_OF_TYPE_DSA_TO_CAMPAIGN_WITHOUT_DSA_SETTING.
• לא ניתן להשתמש במילות מפתח חיוביות בסוג קבוצת המודעות הזה. ניתן להשתמש בקהל, יעדי מודעות דינמיות ומילות מפתח שליליות.
• כמו בכל קבוצות המודעות, לא ניתן לשנות את השדה type לאחר היצירה.
• בקבוצת המודעות הזו אפשר להשתמש רק בפורמטים של מודעות שקשורים למודעות דינמיות לרשת החיפוש.

דוגמת הקוד הבאה ממחישה איך ליצור קבוצת מודעות מסוג 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.V16.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::V16::Resources::AdGroup->new({
    name     => "Earth to Mars Cruises #" . uniqid(),
    campaign => $campaign_resource_name,
    status   => Google::Ads::GoogleAds::V16::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::V16::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.V16.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::V16::Resources::AdGroupAd->new({
      adGroup => $ad_group_resource_name,
      status => Google::Ads::GoogleAds::V16::Enums::AdGroupAdStatusEnum::PAUSED,
      ad     => Google::Ads::GoogleAds::V16::Resources::Ad->new({
          expandedDynamicSearchAd =>
            Google::Ads::GoogleAds::V16::Common::ExpandedDynamicSearchAdInfo->
            new({
              description => "Buy tickets now!"
            })})});

  # Create an ad group ad operation.
  my $ad_group_ad_operation =
    Google::Ads::GoogleAds::V16::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
      

השדה final_urls מחושב על ידי Google Ads כאשר היא יוצרת את המודעה הדינמיות לרשת החיפוש. כתוצאה מכך, לא ניתן להגדיר את השדה הזה כשיוצרים מודעות דינמיות לרשת החיפוש. כדי להשתמש בתוכנה למעקב אחר כתובות URL, אפשר לציין אילו פרמטרים נוספים למעקב או הפניות אוטומטיות נחוצים בשדה tracking_url_template. כשמציינים את השדה הזה, צריך לכלול אחד מהפרמטרים הבאים כדי לאפשר ל-Google Ads להוסיף את כתובת ה-URL הסופית שהותאמה שתתקבל:

פרמטר	הסבר
{unescapedlpurl}	כתובת דף נחיתה ללא תו בריחה (escape) — אם רוצים להוסיף משהו לסוף, לדוגמה: {unescapedlpurl}?dsa=true
{escapedlpurl}	כתובת דף נחיתה מסוג escape (בקידוד כתובת URL) – אם רוצים להפנות אוטומטית לכלי מעקב, לדוגמה: http://tracking.com/lp={escapedurl}
{lpurlpath}	רק הפרמטרים של הנתיב והשאילתה מכתובת ה-URL המחושבת, לדוגמה: http://tracking.com.com/track/{lpurlpath}
{lpurl}	מתבצע קידוד של ? ו-= מכתובת דף הנחיתה, שמסתיימת בשאילתת חיפוש. אם הפרמטר נמצא בתחילת השדה tracking_url_template, הוא יוחלף בפועל בערך {unescapedurl}. לדוגמה: http://tracking.com/redir.php?tracking=xyz&url={lpurl}

למשל:

Java

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

ציון קריטריונים למודעות דינמיות לרשת החיפוש

לבסוף, כדאי להגדיר כמה קריטריונים שיפעילו את הצגת המודעות הדינמיות לרשת החיפוש. עושים זאת באמצעות השדה webpage של AdGroupCriterion. שדה webpage הזה מוגדר כאובייקט WebpageInfo שמאפשר בין אחד לשלושה conditions.

conditions הם מכונות WebpageConditionInfo שמאפשרות לכם לציין בדיוק מה לסנן או לחפש בדומיין שצוין קודם בהגדרות הקמפיין. יש חמישה פריטים שאפשר לסנן לפיהם בתוך דומיין:

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 אינם מוגבלים רק לקריטריונים של דפי אינטרנט. תוכל להמשיך להשתמש בסוגי קריטריונים אחרים כדי לצמצם ולשפר את איכות המודעות. חשוב להפעיל שיקול דעת בעת השימוש בקריטריונים נוספים, אבל הוספה של קריטריונים רבים מדי עלולה לפגוע ביעילות של הטירגוט האוטומטי של מודעות דינמיות לרשת החיפוש.