Expanded Text Ads

Expanded text ads are the next generation of the standard AdWords text ad. This new ad type provides longer, more controllable messaging in your ads. The expanded text ad also features:

Two headlines
This ad type has two headline fields. The second headline is concatenated to the first headline field, separated by a dash. On mobile, the combined headline fields may wrap to a second line.
More characters
Both headlines contain 30 characters each, more than standard text ads. Double-width characters such as Chinese, Japanese, and Korean allow for 15 characters.
Expanded description
There is now a single description line with an expanded limit of 80 characters. Truncation and ellipsification have been minimized to make ad display more predictable.
URL customization
Instead of inputting a display URL for your ad, the URL is calculated from the landing page and path fields (path1 and path2), that indicate to a user where they will be directed on a click. Final URL and tracking URL behavior remain the same.

Here's an example ad for Interplanetary Cruises in the AdWords user interface, after being uploaded via the AdWords API.

The fields in this expanded text ad have the following values:

Field Value
headlinePart1 Cruise to Mars #12QjNuTP
headlinePart2 Best Space Cruise Line
description Buy your tickets now!
finalUrls ["http://www.example.com/0"]
path1 all-inclusive
path2 deals

Availability

Expanded text ads can be created and used in both test and production accounts.

Example

Let's walk through the code for the Interplanetary Cruise ad shown above.

Similar to other ad types, ExpandedTextAd can be added through the AdGroupAdService.mutate() method. This ad type requires two headlines, a description, and one or more final URLs.

Java

public static void runExample(
    AdWordsServicesInterface adWordsServices, AdWordsSession session, long adGroupId)
    throws Exception {
  // Get the AdGroupAdService.
  AdGroupAdServiceInterface adGroupAdService =
      adWordsServices.get(session, AdGroupAdServiceInterface.class);

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

  for (int i = 0; i < NUMBER_OF_ADS; i++) {
    // Create expanded text ad.
    ExpandedTextAd expandedTextAd = new ExpandedTextAd();
    expandedTextAd.setHeadlinePart1(String.format("Cruise #%d to Mars", i));
    expandedTextAd.setHeadlinePart2("Best Space Cruise Line");
    expandedTextAd.setDescription("Buy your tickets now!");
    expandedTextAd.setFinalUrls(new String[] {"http://www.example.com/" + i});

    // Create ad group ad.
    AdGroupAd expandedTextAdGroupAd = new AdGroupAd();
    expandedTextAdGroupAd.setAdGroupId(adGroupId);
    expandedTextAdGroupAd.setAd(expandedTextAd);

    // Optional: set the status.
    expandedTextAdGroupAd.setStatus(AdGroupAdStatus.PAUSED);

    // Create the operation.
    AdGroupAdOperation adGroupAdOperation = new AdGroupAdOperation();
    adGroupAdOperation.setOperand(expandedTextAdGroupAd);
    adGroupAdOperation.setOperator(Operator.ADD);

    operations.add(adGroupAdOperation);
  }

  // Add ads.
  AdGroupAdReturnValue result =
      adGroupAdService.mutate(operations.toArray(new AdGroupAdOperation[operations.size()]));

  // Display ads.
  for (AdGroupAd adGroupAdResult : result.getValue()) {
    ExpandedTextAd newAd = (ExpandedTextAd) adGroupAdResult.getAd();
    System.out.printf("Expanded text ad with ID %d and headline '%s - %s' was added.%n",
        newAd.getId(), newAd.getHeadlinePart1(), newAd.getHeadlinePart2());
  }
}

C#

// Get the AdGroupAdService.
AdGroupAdService service =
    (AdGroupAdService) user.GetService(AdWordsService.v201708.AdGroupAdService);

List<AdGroupAdOperation> operations = new List<AdGroupAdOperation>();

for (int i = 0; i < NUMBER_OF_ADS; i++) {
  // Create the expanded text ad.
  ExpandedTextAd expandedTextAd = new ExpandedTextAd();
  expandedTextAd.headlinePart1 = "Cruise #" + i .ToString() + " to Mars";
  expandedTextAd.headlinePart2 = "Best Space Cruise Line";
  expandedTextAd.description = "Buy your tickets now!";
  expandedTextAd.finalUrls = new string[] { "http://www.example.com/" + i };

  AdGroupAd expandedTextAdGroupAd = new AdGroupAd();
  expandedTextAdGroupAd.adGroupId = adGroupId;
  expandedTextAdGroupAd.ad = expandedTextAd;

  // Optional: Set the status.
  expandedTextAdGroupAd.status = AdGroupAdStatus.PAUSED;

  // Create the operation.
  AdGroupAdOperation operation = new AdGroupAdOperation();
  operation.@operator = Operator.ADD;
  operation.operand = expandedTextAdGroupAd;

  operations.Add(operation);
}

AdGroupAdReturnValue retVal = null;

try {
  // Create the ads.
  retVal = service.mutate(operations.ToArray());

  // Display the results.
  if (retVal != null && retVal.value != null) {
    foreach (AdGroupAd adGroupAd in retVal.value) {
      ExpandedTextAd newAd = adGroupAd.ad as ExpandedTextAd;
      Console.WriteLine("Expanded text ad with ID '{0}' and headline '{1} - {2}' was added.",
          newAd.id, newAd.headlinePart1, newAd.headlinePart2);
    }
  } else {
    Console.WriteLine("No expanded text ads were created.");
  }
} catch (Exception e) {
  throw new System.ApplicationException("Failed to create expanded text ad.", e);
}

PHP

public static function runExample(AdWordsServices $adWordsServices,
    AdWordsSession $session, $adGroupId) {
  $adGroupAdService =
      $adWordsServices->get($session, AdGroupAdService::class);

  $operations = [];
  // Create an expanded text ad.
  $expandedTextAd = new ExpandedTextAd();
  $expandedTextAd->setHeadlinePart1('Cruise to Mars #' . uniqid());
  $expandedTextAd->setHeadlinePart2('Best Space Cruise Line');
  $expandedTextAd->setDescription('Buy your tickets now!');
  $expandedTextAd->setFinalUrls(['http://www.example.com']);
  $expandedTextAd->setPath1('all-inclusive');
  $expandedTextAd->setPath2('deals');

  // Create ad group ad.
  $adGroupAd = new AdGroupAd();
  $adGroupAd->setAdGroupId($adGroupId);
  $adGroupAd->setAd($expandedTextAd);
  // Optional: Set additional settings.
  $adGroupAd->setStatus(AdGroupAdStatus::PAUSED);

  // Create ad group ad operation and add it to the list.
  $operation = new AdGroupAdOperation();
  $operation->setOperand($adGroupAd);
  $operation->setOperator(Operator::ADD);
  $operations[] = $operation;

  // Create another expanded text ad.
  $expandedTextAd = new ExpandedTextAd();
  $expandedTextAd->setHeadlinePart1('Cruise to Venus #' . uniqid());
  $expandedTextAd->setHeadlinePart2('Best Space Cruise Line');
  $expandedTextAd->setDescription('Buy your tickets now!');
  $expandedTextAd->setFinalUrls(['http://www.example.com']);

  // Create ad group ad.
  $adGroupAd = new AdGroupAd();
  $adGroupAd->setAdGroupId($adGroupId);
  $adGroupAd->setAd($expandedTextAd);
  // Optional: Set additional settings.
  $adGroupAd->setStatus(AdGroupAdStatus::PAUSED);

  // Create ad group ad operation and add it to the list.
  $operation = new AdGroupAdOperation();
  $operation->setOperand($adGroupAd);
  $operation->setOperator(Operator::ADD);
  $operations[] = $operation;

  // Add expanded text ads on the server.
  $result = $adGroupAdService->mutate($operations);

  // Create the expanded text ads on the server and print out some information
  // for each created expanded text ad.
  foreach ($result->getValue() as $adGroupAd) {
    printf(
        "Expanded text ad with ID %d and headline '%s - %s' was added.\n",
        $adGroupAd->getAd()->getId(),
        $adGroupAd->getAd()->getHeadlinePart1(),
        $adGroupAd->getAd()->getHeadlinePart2()
    );
  }
}

Perl

sub add_expanded_text_ads {
  my $client      = shift;
  my $ad_group_id = shift;

  my $num_ads    = 5;
  my @operations = ();
  for (my $i = 0 ; $i < $num_ads ; $i++) {
    # Create text ad.
    my $expanded_text_ad = Google::Ads::AdWords::v201708::ExpandedTextAd->new({
        headlinePart1 => "Cruise to Mars #" . substr(uniqid(), 0, 8),
        headlinePart2 => "Best Space Cruise Line",
        description   => "Buy your tickets now!",
        finalUrls     => ["http://www.example.com/" . $i],
        path1         => "all-inclusive",
        path2         => "deals"
    });

    # Create ad group ad for the expanded text ad.
    my $ad_group_ad = Google::Ads::AdWords::v201708::AdGroupAd->new({
        adGroupId => $ad_group_id,
        ad        => $expanded_text_ad,
        # Additional properties (non-required).
        status => "PAUSED"
    });

    # Create operation.
    my $ad_group_ad_operation =
      Google::Ads::AdWords::v201708::AdGroupAdOperation->new({
        operator => "ADD",
        operand  => $ad_group_ad
      });
    push @operations, $ad_group_ad_operation;
  }

  # Add expanded text ad.
  my $result =
    $client->AdGroupAdService()->mutate({operations => \@operations});

  # Display results.
  if ($result->get_value()) {
    foreach my $ad_group_ad (@{$result->get_value()}) {
      printf "New expanded text ad with id \"%d\" and " .
        "headline \"%s - %s\" was added.\n",
        $ad_group_ad->get_ad()->get_id(),
        $ad_group_ad->get_ad()->get_headlinePart1(),
        $ad_group_ad->get_ad()->get_headlinePart2();
    }
  } else {
    print "No expanded text ads were added.\n";
  }

  return 1;
}

Python

def main(client, ad_group_id):
  # Initialize appropriate service.
  ad_group_ad_service = client.GetService('AdGroupAdService', version='v201708')

  operations = [
      {
          'operator': 'ADD',
          'operand': {
              'xsi_type': 'AdGroupAd',
              'adGroupId': ad_group_id,
              'ad': {
                  'xsi_type': 'ExpandedTextAd',
                  'headlinePart1': ('Cruise #%s to Mars'
                                    % str(uuid.uuid4())[:8]),
                  'headlinePart2': 'Best Space Cruise Line',
                  'description': 'Buy your tickets now!',
                  'finalUrls': ['http://www.example.com/%s' % i],
              },
              # Optional fields.
              'status': 'PAUSED'
          }
      } for i in range(NUMBER_OF_ADS)
  ]
  ads = ad_group_ad_service.mutate(operations)

  # Display results.
  for ad in ads['value']:
    print ('Ad of type "%s" with id "%d" was added.'
           '\n\theadlinePart1: %s\n\theadlinePart2: %s'
           % (ad['ad']['Ad.Type'], ad['ad']['id'],
              ad['ad']['headlinePart1'], ad['ad']['headlinePart2']))

Ruby

ad_group_ad_srv = adwords.service(:AdGroupAdService, API_VERSION)

# Create text ads.
# The 'xsi_type' field allows you to specify the xsi:type of the object
# being created. It's only necessary when you must provide an explicit
# type that the client library can't infer.
operations = 5.times.map do |i|
  expanded_text_ad = {
    :xsi_type => 'ExpandedTextAd',
    :headline_part1 => 'Cruise to Mars #%d' % (Time.new.to_f * 1000).to_i,
    :headline_part2 => 'Best Space Cruise Line',
    :description => 'Buy your tickets now!',
    :final_urls => ['http://www.example.com/%d' % i],
    :path1 => 'all-inclusive',
    :path2 => 'deals'
  }

  ad_group_ad = {
    :ad_group_id => ad_group_id,
    :ad => expanded_text_ad,
    # Additional properties (non-required).
    :status => 'PAUSED'
  }

  operation = {
    :operator => 'ADD',
    :operand => ad_group_ad
  }
end

# Add ads.
response = ad_group_ad_srv.mutate(operations)
if response and response[:value]
  response[:value].each do |ad_group_ad|
    puts ('New expanded text ad with id "%d" and headline "%s - %s" was ' +
        'added.') % [ad_group_ad[:ad][:id], ad_group_ad[:ad][:headline_part1],
        ad_group_ad[:ad][:headline_part2]]
  end
else
  raise StandardError, 'No ads were added.'
end

To retrieve the expanded text ads you've created, call AdGroupAdService.get() with a predicate filtering on AdType EXPANDED_TEXT_AD.

Java

public static void runExample(
    AdWordsServicesInterface adWordsServices, AdWordsSession session, Long adGroupId)
    throws Exception {
  // Get the AdGroupAdService.
  AdGroupAdServiceInterface adGroupAdService =
      adWordsServices.get(session, AdGroupAdServiceInterface.class);

  int offset = 0;
  boolean morePages = true;

  // Create selector.
  SelectorBuilder builder = new SelectorBuilder();
  Selector selector =
      builder
          .fields(
              AdGroupAdField.Id,
              AdGroupAdField.Status,
              AdGroupAdField.HeadlinePart1,
              AdGroupAdField.HeadlinePart2,
              AdGroupAdField.Description)
          .orderAscBy(AdGroupAdField.Id)
          .offset(offset)
          .limit(PAGE_SIZE)
          .equals(AdGroupAdField.AdGroupId, adGroupId.toString())
          .in(AdGroupAdField.Status, "ENABLED", "PAUSED")
          .equals("AdType", "EXPANDED_TEXT_AD")
          .build();

  while (morePages) {
    // Get all ads.
    AdGroupAdPage page = adGroupAdService.get(selector);

    // Display ads.
    if (page.getEntries() != null && page.getEntries().length > 0) {
      for (AdGroupAd adGroupAd : page.getEntries()) {
        ExpandedTextAd expandedTextAd = (ExpandedTextAd) adGroupAd.getAd();
        System.out.printf(
            "Expanded text ad with ID %d, status '%s', and headline '%s - %s' was found.%n",
            adGroupAd.getAd().getId(),
            adGroupAd.getStatus(),
            expandedTextAd.getHeadlinePart1(),
            expandedTextAd.getHeadlinePart2());
      }
    } else {
      System.out.println("No expanded text ads were found.");
    }

    offset += PAGE_SIZE;
    selector = builder.increaseOffsetBy(PAGE_SIZE).build();
    morePages = offset < page.getTotalNumEntries();
  }
}

C#

// Get the AdGroupAdService.
AdGroupAdService service =
    (AdGroupAdService) user.GetService(AdWordsService.v201708.AdGroupAdService);

// Create a selector.
Selector selector = new Selector() {
  fields = new string[] {
    ExpandedTextAd.Fields.Id, AdGroupAd.Fields.Status, ExpandedTextAd.Fields.HeadlinePart1,
    ExpandedTextAd.Fields.HeadlinePart2, ExpandedTextAd.Fields.Description
  },
  ordering = new OrderBy[] { OrderBy.Asc(ExpandedTextAd.Fields.Id) },
  predicates = new Predicate[] {
    // Restrict the fetch to only the selected ad group id.
    Predicate.Equals(AdGroupAd.Fields.AdGroupId, adGroupId),

    // Retrieve only expanded text ads.
    Predicate.Equals("AdType", "EXPANDED_TEXT_AD"),

    // By default disabled ads aren't returned by the selector. To return
    // them include the DISABLED status in the statuses field.
    Predicate.In(AdGroupAd.Fields.Status, new string[] {
      AdGroupAdStatus.ENABLED.ToString(),
      AdGroupAdStatus.PAUSED.ToString(),
      AdGroupAdStatus.DISABLED.ToString()
    })
  },
  paging = Paging.Default
};

AdGroupAdPage page = new AdGroupAdPage();

try {
  do {
    // Get the expanded text ads.
    page = service.get(selector);

    // Display the results.
    if (page != null && page.entries != null) {
      int i = selector.paging.startIndex;

      foreach (AdGroupAd adGroupAd in page.entries) {
        ExpandedTextAd expandedTextAd = (ExpandedTextAd) adGroupAd.ad;
        Console.WriteLine("{0} : Expanded text ad with ID '{1}', headline '{2} - {3}' " +
            "and description '{4} was found.", i + 1, expandedTextAd.id,
            expandedTextAd.headlinePart1, expandedTextAd.headlinePart2,
            expandedTextAd.description);
        i++;
      }
    }
    selector.paging.IncreaseOffset();
  } while (selector.paging.startIndex < page.totalNumEntries);
  Console.WriteLine("Number of expanded text ads found: {0}", page.totalNumEntries);
} catch (Exception e) {
  throw new System.ApplicationException("Failed to get expanded text ads", e);
}

PHP

public static function runExample(AdWordsServices $adWordsServices,
    AdWordsSession $session, $adGroupId) {
  $adGroupAdService =
      $adWordsServices->get($session, AdGroupAdService::class);

  // Create a selector to select all ads for the specified ad group.
  $selector = new Selector();
  $selector->setFields(
      ['Id', 'Status', 'HeadlinePart1', 'HeadlinePart2', 'Description']);
  $selector->setOrdering([new OrderBy('Id', SortOrder::ASCENDING)]);
  $selector->setPredicates([
      new Predicate('AdGroupId', PredicateOperator::IN, [$adGroupId]),
      new Predicate('AdType', PredicateOperator::IN,
          [AdType::EXPANDED_TEXT_AD]),
      new Predicate('Status', PredicateOperator::IN,
          [AdGroupAdStatus::ENABLED, AdGroupAdStatus::PAUSED])
  ]);
  $selector->setPaging(new Paging(0, self::PAGE_LIMIT));

  $totalNumEntries = 0;
  do {
    // Retrieve ad group ads one page at a time, continuing to request pages
    // until all ad group ads have been retrieved.
    $page = $adGroupAdService->get($selector);

    // Print out some information for each ad group ad.
    if ($page->getEntries() !== null) {
      $totalNumEntries = $page->getTotalNumEntries();
      foreach ($page->getEntries() as $adGroupAd) {
        printf(
            "Expanded text ad with ID %d, status '%s', and headline "
                . "'%s - %s' was found.\n",
            $adGroupAd->getAd()->getId(),
            $adGroupAd->getStatus(),
            $adGroupAd->getAd()->getHeadlinePart1(),
            $adGroupAd->getAd()->getHeadlinePart2()
        );
      }
    }

    $selector->getPaging()->setStartIndex(
        $selector->getPaging()->getStartIndex() + self::PAGE_LIMIT);
  } while ($selector->getPaging()->getStartIndex() < $totalNumEntries);

  printf("Number of results found: %d\n", $totalNumEntries);
}

Perl

sub get_expanded_text_ads {
  my $client      = shift;
  my $ad_group_id = shift;

  # Create predicates.
  my $ad_group_predicate = Google::Ads::AdWords::v201708::Predicate->new({
      field    => "AdGroupId",
      operator => "IN",
      values   => [$ad_group_id]});
  my $status_predicate = Google::Ads::AdWords::v201708::Predicate->new({
      field    => "Status",
      operator => "IN",
      values   => ["ENABLED", "PAUSED"]});
  my $ad_type_predicate = Google::Ads::AdWords::v201708::Predicate->new({
      field    => "AdType",
      operator => "EQUALS",
      values   => ["EXPANDED_TEXT_AD"]});

  # Create selector.
  my $paging = Google::Ads::AdWords::v201708::Paging->new({
      startIndex    => 0,
      numberResults => PAGE_SIZE
  });
  my $selector = Google::Ads::AdWords::v201708::Selector->new({
      fields =>
        ["Id", "Status", "HeadlinePart1", "HeadlinePart2", "Description"],
      predicates =>
        [$ad_group_predicate, $status_predicate, $ad_type_predicate],
      ordering => [
        Google::Ads::AdWords::v201708::OrderBy->new({
            field     => "Id",
            sortOrder => "ASCENDING"
          })
      ],
      paging => $paging
    });

  # Paginate through results.
  # The contents of the subroutine will be executed for each text ad.
  Google::Ads::AdWords::Utilities::PageProcessor->new({
      client   => $client,
      service  => $client->AdGroupAdService(),
      selector => $selector
    }
    )->process_entries(
    sub {
      my ($ad_group_ad) = @_;
      printf "Expanded text ad with id \"%d\", status \"%s\", and " .
        "headline \"%s - %s\" was found.\n",
        $ad_group_ad->get_ad()->get_id(),
        $ad_group_ad->get_status(),
        $ad_group_ad->get_ad()->get_headlinePart1(),
        $ad_group_ad->get_ad()->get_headlinePart2();
    });

  return 1;
}

Python

def main(client, ad_group_id):
  # Initialize appropriate service.
  ad_group_ad_service = client.GetService('AdGroupAdService', version='v201708')

  # Construct selector and get all ads for a given ad group.
  offset = 0
  selector = {
      'fields': ['Id', 'AdGroupId', 'Status', 'HeadlinePart1', 'HeadlinePart2',
                 'Description'],
      'predicates': [
          {
              'field': 'AdGroupId',
              'operator': 'EQUALS',
              'values': [ad_group_id]
          },
          {
              'field': 'AdType',
              'operator': 'EQUALS',
              'values': ['EXPANDED_TEXT_AD']
          }
      ],
      'paging': {
          'startIndex': str(offset),
          'numberResults': str(PAGE_SIZE)
      },
      'ordering': [
          {
              'field': 'Id',
              'sortOrder': 'ASCENDING'
          }
      ]
  }
  more_pages = True
  while more_pages:
    page = ad_group_ad_service.get(selector)

    # Display results.
    if 'entries' in page:
      for ad in page['entries']:
        print ('ExpandedTextAd with id "%d", AdGroupId "%d", status "%s", '
               'headlinePart1 "%s", headlinePart2 "%s", description "%s" was '
               'found.' % (ad['ad']['id'], ad['adGroupId'], ad['status'],
                           ad['ad']['headlinePart1'], ad['ad']['headlinePart2'],
                           ad['ad']['description']))
    else:
      print 'No ads were found.'
    offset += PAGE_SIZE
    selector['paging']['startIndex'] = str(offset)
    more_pages = offset < int(page['totalNumEntries'])

Ruby

ad_group_ad_srv = adwords.service(:AdGroupAdService, API_VERSION)

# Get all the ads for this ad group.
selector = {
  :fields => ['Id', 'Status', 'HeadlinePart1', 'HeadlinePart2',
      'Description'],
  :ordering => [{:field => 'Id', :sort_order => 'ASCENDING'}],
  # By default, disabled ads aren't returned by the selector. To return them,
  # include the DISABLED status in a predicate.
  :predicates => [
    {
      :field => 'AdGroupId',
      :operator => 'IN',
      :values => [ad_group_id]
    },
    {
      :field => 'Status',
      :operator => 'IN',
      :values => ['ENABLED', 'PAUSED']
    },
    {
      :field => 'AdType',
      :operator => 'EQUALS',
      :values => ['EXPANDED_TEXT_AD']
    }
  ],
  :paging => {
    :start_index => 0,
    :number_results => PAGE_SIZE
  }
}

# Set initial values.
offset, page = 0, {}

begin
  page = ad_group_ad_srv.get(selector)
  if page[:entries]
    page[:entries].each do |ad_group_ad|
      puts ('Expanded text ad with ID "%d", status "%s", and headline ' +
          '"%s - %s" was found.') % [ad_group_ad[:ad][:id],
          ad_group_ad[:status], ad_group_ad[:ad][:headline_part1],
          ad_group_ad[:ad][:headline_part2]]
    end
    # Increment values to request the next page.
    offset += PAGE_SIZE
    selector[:paging][:start_index] = offset
  end
end while page[:total_num_entries] > offset

if page.include?(:total_num_entries)
  puts "\tAd group ID %d has %d expanded text ad(s)." %
      [ad_group_id, page[:total_num_entries]]
end

Reporting

The AdType in reports for expanded text ads is EXPANDED_TEXT_AD. To make it easier to retrieve data related to expanded text ads in the Ad Performance report, the following fields have been made available:

Upgrade tips

The upgrade to expanded text ads will require your intervention: In many cases, the second headline will need new content, and you'll need to decide when to enable the new expanded text ad and when to disable the old standard text ad.

To upgrade your standard text ads to expanded text ads:

  1. Create the new expanded text ad in a PAUSED state based on the data in the standard text ad. Take into consideration that description1 in standard text ads is 35 characters, while headlinePart2 in expanded text ads is 30 characters: If you simply copy the text from the text ad's description1 to the expanded text ad's headlinePart2, an error will result.

  2. Wait for the new expanded text ad's approvalStatus to become APPROVED.

  3. If you're using fully automated conversion-based bidding (Target CPA or Target ROAS), we recommend transitioning to expanded text ads gradually by letting the expanded text ads run in parallel with the standard text ads for some time before removing the standard text ads.

  4. Send an AdGroupAdService.mutate() request with two operations:

    • Set the new expanded text ad status to ENABLED.
    • Set the old standard text ad status to DISABLED.

If you're not sure where to start upgrading or experimenting, start with the standard text ads that are performing the worst because you'll get improved clickthrough rates with the new expanded text ads.

Upgrade progress

There are a few ways to measure your progress when upgrading.

Manager Account Level -- AdWords UI

Sign in to your manager account.

  • Click on Accounts.
  • In the left-hand navigation bar, click Notifications.
  • Select Filter > Create Filter.
  • For Category, select Other.
  • For Type, choose these 3 values: "Finish text ad upgrade", "Start text ad ugprade", "Continue text ad upgrade".
  • Click Apply.

This results in a list of accounts with the number of standard text ads that still need to be upgraded.

Client Account Level -- AdWords UI

Navigate to your AdWords client account.

  • Click the Ads tab.
  • Select Filter > Create Filter.
  • Filter on Ad type as Text ad.
  • Click Apply.

This results in a list of standard text ads.

Client Account Level -- API

Using the AdGroupAdService.get() method, you can filter your ads by ad type. To retrieve a list of standard text ads, you would add the filter AdType as TEXT_AD. Start with the ads that are in an ENABLED or PAUSED state.

Here's an example report query that retrieves all your standard text ads that need to be upgraded:

SELECT Id, Status, AdGroupId, AdGroupStatus, CampaignId, CampaignStatus
FROM AD_PERFORMANCE_REPORT
WHERE AdType = TEXT_AD AND Status != DISABLED
AND AdGroupStatus != REMOVED
AND CampaignStatus != REMOVED

Upgrade helper

ETA Transition Helper is available to assist in upgrading standard text ads in bulk to expanded text ads.

The tool has two main components:

  1. An AdWords script that copies your standard text ads to a Google Sheet and then helps you write expanded text ads to add to your AdWords account.

  2. A Google Sheet that displays your standard text ads and allows you to configure the associated expanded text ads.

Code examples

You can view the complete code samples at the links below.

Send feedback about...

AdWords API
AdWords API
Need help? Visit our support page.