Customizing Text Ads

Ad customizers are a very powerful tool that allows you to customize the text content of extended text ads by using text placeholders, countdowns, and IF functions.

An ad customizer is a feed-based solution for injecting dynamic information into your ads. You can set up a feed with targeting options for specific campaigns, ad groups, and/or keywords, and then create ads that reference the information in the feed, so the values in the feed are dynamically injected in your ads at serve time.

You can put strings, prices, numbers, and even a countdown to a specific date or time in your ad.

Key Point: Dynamic replacements can occur in ad titles and description lines, but not in display or final URLs.

Ad customizers

A common use case for ad customizers is promoting sale prices on items during specific date ranges. To do this, you set up a feed with a string attribute for the item name, another string attribute for the price, and a date attribute for the date your sale ends, then populate feed items accordingly.

When setting up an ad, you reference the feed item, its name attribute, and its sale price attribute in the ad text fields, and Google Ads automatically populates the ad with the name and price from the feed item.

To use the feed item's end date, you include the date attribute in a function that tells Google Ads to display a countdown to the end date in your ad. When creating the ad, reference the feed item and its name, sale price, and end date attributes, and Google Ads will automatically populate the ad with the name, price, and end date from the feed item.

This will allow you to reuse the ad with another product sale or with the next sale of the same product, by updating your feed item's price and end date values, instead of creating a new ad for each product or for each sale.

The following sections describe all phases of this use case, including how to:

• Set up the feed and its attributes
• Map the feed to the "Ad Customizer" placeholder type
• Create feed items with the values you want to appear in your ads
• Target feed items to a specific campaign, ad group or keyword
• Use the feed in an ad
• Add a countdown
• Add an IF function

Set up the feed

The first step is to create a feed with all of the attributes you'll need to customize your ad.

Show me a Java example of creating a feed with three attributes: two of type STRING and one of type DATE_TIME

private String createAdCustomizerFeed(
    GoogleAdsClient googleAdsClient, long customerId, String feedName) {

  // Creates three feed attributes: a name, a price and a date. The attribute names are arbitrary
  // choices and will be used as placeholders in the ad text fields.
  FeedAttribute nameAttribute =
      FeedAttribute.newBuilder()
          .setName(StringValue.of("Name"))
          .setType(FeedAttributeType.STRING)
          .build();

  FeedAttribute priceAttribute =
      FeedAttribute.newBuilder()
          .setName(StringValue.of("Price"))
          .setType(FeedAttributeType.STRING)
          .build();

  FeedAttribute dateAttribute =
      FeedAttribute.newBuilder()
          .setName(StringValue.of("Date"))
          .setType(FeedAttributeType.DATE_TIME)
          .build();

  Feed adCustomizerFeed =
      Feed.newBuilder()
          .setName(StringValue.of(feedName))
          .addAttributes(nameAttribute)
          .addAttributes(priceAttribute)
          .addAttributes(dateAttribute)
          .build();

  FeedOperation feedOperation = FeedOperation.newBuilder().setCreate(adCustomizerFeed).build();

  try (FeedServiceClient feedServiceClient =
      googleAdsClient.getLatestVersion().createFeedServiceClient()) {

    MutateFeedsResponse response =
        feedServiceClient.mutateFeeds(Long.toString(customerId), ImmutableList.of(feedOperation));

    String feedResourceName = response.getResults(0).getResourceName();
    System.out.printf("Added feed with resource name %s.%n", feedResourceName);
    return feedResourceName;
  }
}
AddAdCustomizer.java

Take note of the resource name for the feed and the IDs for the feed attributes, as you'll need them when setting up the feed items. You can retrieve the feed attributes with a GAQL query that uses the resource name to filter results:

SELECT feed.attributes, feed.name FROM feed WHERE feed.resource_name = '%s'

Show me an example of feed attribute retrieval

private Map<String, FeedAttribute> getFeedAttributes(
    GoogleAdsClient googleAdsClient, long customerId, String feedResourceName) {
  String query =
      String.format(
          "SELECT feed.attributes, feed.name FROM feed WHERE feed.resource_name = '%s'",
          feedResourceName);

  SearchGoogleAdsRequest request =
      SearchGoogleAdsRequest.newBuilder()
          .setCustomerId(Long.toString(customerId))
          .setPageSize(PAGE_SIZE)
          .setQuery(query)
          .build();

  Map<String, FeedAttribute> feedAttributes = new HashMap<>();
  try (GoogleAdsServiceClient googleAdsServiceClient =
      googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
    SearchPagedResponse searchPagedResponse = googleAdsServiceClient.search(request);

    Feed feed = searchPagedResponse.iterateAll().iterator().next().getFeed();

    System.out.printf(
        "Found the following attributes for feed with name '%s':%n", feed.getName().getValue());
    for (FeedAttribute feedAttribute : feed.getAttributesList()) {
      System.out.printf(
          "\t'%s' with id %d and type '%s'%n",
          feedAttribute.getName().getValue(),
          feedAttribute.getId().getValue(),
          feedAttribute.getType());
      feedAttributes.put(feedAttribute.getName().getValue(), feedAttribute);
    }
  }
  return feedAttributes;
}
AddAdCustomizer.java

We are going to use the attribute IDs later, so we store them in a structure that allows us to retrieve them by attribute name.

Create a FeedMapping

The next step is declaring that the feed you just created is to be used for ad customizing by mapping it to the AdCustomizer placeholder type and each of its fields to a specific AdCustomizerPlaceholderField:

Show me an example of FeedMapping creation

private void createAdCustomizerMapping(
    GoogleAdsClient googleAdsClient,
    long customerId,
    String feedResourceName,
    Map<String, FeedAttribute> feedAttributes) {

  // Map the feed attributes to ad customizer placeholder fields.
  // For a full list of ad customizer placeholder fields, see
  // https://developers.google.com/google-ads/api/reference/rpc/google.ads.googleads.v3.enums#google.ads.googleads.v3.enums.AdCustomizerPlaceholderFieldEnum.AdCustomizerPlaceholderField
  AttributeFieldMapping nameFieldMapping =
      AttributeFieldMapping.newBuilder()
          .setFeedAttributeId(feedAttributes.get("Name").getId())
          .setAdCustomizerField(AdCustomizerPlaceholderField.STRING)
          .build();

  AttributeFieldMapping priceFieldMapping =
      AttributeFieldMapping.newBuilder()
          .setFeedAttributeId(feedAttributes.get("Price").getId())
          .setAdCustomizerField(AdCustomizerPlaceholderField.PRICE)
          .build();

  AttributeFieldMapping dateFieldMapping =
      AttributeFieldMapping.newBuilder()
          .setFeedAttributeId(feedAttributes.get("Date").getId())
          .setAdCustomizerField(AdCustomizerPlaceholderField.DATE)
          .build();

  FeedMapping feedMapping =
      FeedMapping.newBuilder()
          .setFeed(StringValue.of(feedResourceName))
          // Sets the feed to the AD_CUSTOMIZER placeholder type.
          .setPlaceholderType(PlaceholderType.AD_CUSTOMIZER)
          .addAttributeFieldMappings(nameFieldMapping)
          .addAttributeFieldMappings(priceFieldMapping)
          .addAttributeFieldMappings(dateFieldMapping)
          .build();

  FeedMappingOperation feedMappingOperation =
      FeedMappingOperation.newBuilder().setCreate(feedMapping).build();

  try (FeedMappingServiceClient feedMappingServiceClient =
      googleAdsClient.getLatestVersion().createFeedMappingServiceClient()) {

    MutateFeedMappingsResponse response =
        feedMappingServiceClient.mutateFeedMappings(
            Long.toString(customerId), ImmutableList.of(feedMappingOperation));

    System.out.printf(
        "Added feed mapping with resource name %s.%n", response.getResults(0).getResourceName());
  }
}
AddAdCustomizer.java

Create feed items

At this point you can create two different feed items, for two different product sales, that will be dynamically inserted in your expanded text ads:

Show me an example of feed item creation

private List<String> createFeedItems(
    GoogleAdsClient googleAdsClient,
    long customerId,
    String feedResourceName,
    Map<String, FeedAttribute> feedAttributes) {

  List<FeedItemOperation> feedItemOperations = new ArrayList<>();

  DateTime marsDate = DateTime.now().withDayOfMonth(1).withHourOfDay(0).withMinuteOfHour(0);
  feedItemOperations.add(
      createFeedItemOperation(
          "Mars",
          "$1234.56",
          marsDate.toString("yyyyMMdd HHmmss"),
          feedResourceName,
          feedAttributes));

  DateTime venusDate = DateTime.now().withDayOfMonth(15).withHourOfDay(0).withMinuteOfHour(0);
  feedItemOperations.add(
      createFeedItemOperation(
          "Venus",
          "$1450.00",
          venusDate.toString("yyyyMMdd HHmmss"),
          feedResourceName,
          feedAttributes));

  try (FeedItemServiceClient feedItemServiceClient =
      googleAdsClient.getLatestVersion().createFeedItemServiceClient()) {
    List<String> feedItemResourceNames = new ArrayList<>();
    MutateFeedItemsResponse response =
        feedItemServiceClient.mutateFeedItems(Long.toString(customerId), feedItemOperations);

    System.out.printf("Added %d feed items:%n", response.getResultsCount());

    for (MutateFeedItemResult result : response.getResultsList()) {
      String feedItemResourceName = result.getResourceName();
      feedItemResourceNames.add(feedItemResourceName);
      System.out.printf("Added feed item with resource name %s.%n", feedItemResourceName);
    }
    return feedItemResourceNames;
  }
}
AddAdCustomizer.java

The helper function creates a FeedItemOperation object and sets the value of each feed attribute:

Show me the helper function that creates FeedItemOperation objects

private FeedItemOperation createFeedItemOperation(
    String name,
    String price,
    String date,
    String feedResourceName,
    Map<String, FeedAttribute> feedAttributes) {
  FeedItemAttributeValue nameAttributeValue =
      FeedItemAttributeValue.newBuilder()
          .setFeedAttributeId(feedAttributes.get("Name").getId())
          .setStringValue(StringValue.of(name))
          .build();

  FeedItemAttributeValue priceAttributeValue =
      FeedItemAttributeValue.newBuilder()
          .setFeedAttributeId(feedAttributes.get("Price").getId())
          .setStringValue(StringValue.of(price))
          .build();

  FeedItemAttributeValue dateAttributeValue =
      FeedItemAttributeValue.newBuilder()
          .setFeedAttributeId(feedAttributes.get("Date").getId())
          .setStringValue(StringValue.of(date))
          .build();

  FeedItem feedItem =
      FeedItem.newBuilder()
          .setFeed(StringValue.of(feedResourceName))
          .addAttributeValues(nameAttributeValue)
          .addAttributeValues(priceAttributeValue)
          .addAttributeValues(dateAttributeValue)
          .build();

  return FeedItemOperation.newBuilder().setCreate(feedItem).build();
}
AddAdCustomizer.java

Set up feed item targeting

To be sure that the items will be fetched only for a specific ad group, their targeting can be restricted by creating a FeedItemTarget that binds a feed item to an ad group:

Show me an example of feed item targeting setup

private void createFeedItemTargets(
    GoogleAdsClient googleAdsClient,
    long customerId,
    List<Long> adGroupIds,
    List<String> feedItemResourceNames) {

  // Bind each feed item to a specific ad group to make sure it will only be used to customize
  // ads inside that ad group; using the feed item elsewhere will result in an error.
  for (int i = 0; i < feedItemResourceNames.size(); i++) {
    String feedItemResourceName = feedItemResourceNames.get(i);
    Long adGroupId = adGroupIds.get(i);

    FeedItemTarget feedItemTarget =
        FeedItemTarget.newBuilder()
            .setAdGroup(StringValue.of(ResourceNames.adGroup(customerId, adGroupId)))
            .setFeedItem(StringValue.of(feedItemResourceName))
            .build();

    FeedItemTargetOperation feedItemTargetOperation =
        FeedItemTargetOperation.newBuilder().setCreate(feedItemTarget).build();

    try (FeedItemTargetServiceClient feedItemTargetServiceClient =
        googleAdsClient.getLatestVersion().createFeedItemTargetServiceClient()) {

      MutateFeedItemTargetsResponse response =
          feedItemTargetServiceClient.mutateFeedItemTargets(
              Long.toString(customerId), ImmutableList.of(feedItemTargetOperation));

      String feedItemTargetResourceName = response.getResults(0).getResourceName();
      System.out.printf(
          "Added feed item target with resource name '%s'.%n", feedItemTargetResourceName);
    }
  }
}
AddAdCustomizer.java

Feed item targets can restrict feed items to be fetched for several different resource types, like campaigns, ad groups, keywords, devices and locations: to see the complete list of possible resources that a feed item can target, see the FeedItemTarget resource.

Use the feed in an ad

Once the feed is set up, you can reference it from any ad in the system.

When setting up an ad, you reference a feed and its attributes by name, not by ID. This is different from the other steps, where you use the system-generated IDs.

The syntax for inserting a custom value from a feed is {=FeedName.AttributeName}. If you want to specify a default value, the syntax would be {=FeedName.AttributeName:default value}. For example, using our feed above, if you want to insert the price of an object in the string with a default of $10, use {=AdCustomizerFeed.Price:$10}:

Show me an example of how to use the feed to customize ads

private void createAdsWithCustomizations(
    GoogleAdsClient googleAdsClient, long customerId, List<Long> adGroupIds, String feedName) {

  // Creates an expanded text ad using the feed attribute names as placeholders.
  ExpandedTextAdInfo expandedTextAdInfo =
      ExpandedTextAdInfo.newBuilder()
          .setHeadlinePart1(
              StringValue.of(String.format("Luxury cruise to {=%s.Name}", feedName)))
          .setHeadlinePart2(StringValue.of(String.format("Only {=%s.Price}", feedName)))
          .setDescription(
              StringValue.of(String.format("Offer ends in {=countdown(%s.Date)}!", feedName)))
          .build();

  Ad ad =
      Ad.newBuilder()
          .setExpandedTextAd(expandedTextAdInfo)
          .addFinalUrls(StringValue.of("http://www.example.com"))
          .build();

  List<AdGroupAdOperation> adGroupAdOperations = new ArrayList<>();

  // Creates the same ad in all ad groups. When they serve, they will show different values,
  // since they match different feed items.
  for (Long adGroupId : adGroupIds) {
    AdGroupAd adGroupAd =
        AdGroupAd.newBuilder()
            .setAd(ad)
            .setAdGroup(StringValue.of(ResourceNames.adGroup(customerId, adGroupId)))
            .build();

    AdGroupAdOperation adGroupAdOperation =
        AdGroupAdOperation.newBuilder().setCreate(adGroupAd).build();

    adGroupAdOperations.add(adGroupAdOperation);
  }

  try (AdGroupAdServiceClient adGroupAdServiceClient =
      googleAdsClient.getLatestVersion().createAdGroupAdServiceClient()) {

    MutateAdGroupAdsResponse response =
        adGroupAdServiceClient.mutateAdGroupAds(Long.toString(customerId), adGroupAdOperations);

    System.out.printf("Added %d ads:%n", response.getResultsCount());
    for (MutateAdGroupAdResult result : response.getResultsList()) {
      System.out.printf("Added an ad with resource name '%s'.%n", result.getResourceName());
    }
  }
}
AddAdCustomizer.java

The references to the feed with name feedName are populated at serving time with matching data from a feed item within that feed that is targeted to match the current ad group. The ad won't serve if no match is found.

Note: All feed references in a given ad must refer to the same feed. Feed names and feed attribute names must have colons escaped with a backslash.

The API validates ads that include references to ad customizers: If no feed with the specified name is mapped to the ad placeholder type, or no attribute with a specified name exists in the feed, the ad is rejected.

If you change the name of a feed when ads are referencing it, the ads are automatically updated to reference the new feed name. If you delete a feed when ads are referencing it, those ads will no longer serve.

Note: If you don't have a default value, you must have an ad in each ad group that doesn't use ad customization parameters, so the system has a backup ad to use in case nothing in the feed matches, or if the instantiated text exceeds character limits. If no such ad exists, none of the ads using customizers in that ad group will serve.

Ads using customizers are subject to approvals just like any other ads. Feed items and ads can both be disapproved separately, though disapproval of either will prevent the ad from serving. In rare cases where each is individually fine, but the combination of the two is a violation, the ad will be disapproved to prevent serving.

Using countdowns

The COUNTDOWN function allows you to dynamically change the way you display a date field so it shows how much time (days, hours) is left.

For example, the description of the ad example above is set to 'Offer ends in {=COUNTDOWN(feedName.Date)}!' At serve time, the ad will show "Offer ends in 5 days!" or "Offer ends in 4 hours!" based on the time left.

Once the date specified in the countdown is past, the ad will no longer serve until the date is updated again.

The countdown function takes three arguments, but only the first is required:

• timestamp: The date to which you are counting down. This value can be a reference to a feed attribute or a specific date literal.
• language: The localization in which the countdown should be displayed. If unspecified, this defaults to en-US.
• days_before: The number of days before the timestamp that this ad can start serving. For example, if it's 6 days before the specified time, but this field is set to 5, the ad won't serve. If unspecified, no restrictions are added.

For instance, you could use {=COUNTDOWN(AdCustomizerFeed.Date, 'es', 3)} to change the language to Spanish, and restrict the ad so it doesn't appear in search results until 3 days before the date specified.

The COUNTDOWN function counts down to an event in the timezone of the user making the query. A variant of COUNTDOWN, called GLOBAL_COUNTDOWN, counts down to a specific time in your account's time zone. GLOBAL_COUNTDOWN takes all the same parameters as COUNTDOWN.

Using IF functions

For an easier way to customize your ads, IF functions let you insert a customized message in your ad based on who is searching and what device they're searching on, all without using a feed. The default text is optional.

Dimension	Criteria	Syntax	Example
device	mobile	{=IF(device=mobile,text to insert):optional default text}	{=IF(device=mobile,"Quick, Easy, Mobile Booking"):"Best price guarantee"}
audience	Any valid user list name in your account (if list name matches multiple lists in advertiser account, we will randomly pick any)	{=IF(audience IN (userlist1,userlist2),text to insert):optional default text}	{=IF(audience IN (returning visitors,cart abandoners),30%):25%}