Responsive Ads for Display

The responsive ad for Display is an ad that automatically adjusts its size, appearance, and format to fit available ad spaces on the Google Display Network.

ResponsiveDisplayAd contains the following elements:

  • short headline
  • long headline
  • description
  • business name
  • marketing image
  • landscape logo and square marketing images
  • call-to-action text (optional)
  • logo (optional)
  • promotion text (optional)
  • price prefix (optional)

Read more about these fields.

Example

You create responsive ads in two phases:

  1. Upload the marketing image, optional logo, landscape logo, and square marketing images using the MediaService with the upload() method. Keep track of the ID that comes back. You'll need that later when adding your ad. You can optionally upload a logo image the same way. Once an image is uploaded through the media service, it can be reused for multiple ads later on.

  2. Create a ResponsiveDisplayAd using AdGroupAdService. For the marketingImage, logoImage, landscapeLogoImage, and squareMarketingImage, make sure to reference the media IDs that were returned in the first phase.

Now, let's walk through an example of adding an image to a campaign targeting the display network. Here's an example image for Interplanetary Cruises that meets the specifications for images in responsive ads.

Java

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

  // Get the AdGroupAdService.
  AdGroupAdServiceInterface adGroupAdService =
      adWordsServices.get(session, AdGroupAdServiceInterface.class);

  // Create a responsive display ad.
  ResponsiveDisplayAd responsiveDisplayAd = new ResponsiveDisplayAd();

  // This ad format does not allow the creation of an image using the
  // Image.data field. An image must first be created using the MediaService,
  // and Image.mediaId must be populated when creating the ad.
  long marketingImageMediaId = uploadImage(mediaService, "https://goo.gl/3b9Wfh");
  Image marketingImage = new Image();
  marketingImage.setMediaId(marketingImageMediaId);
  responsiveDisplayAd.setMarketingImage(marketingImage);

  responsiveDisplayAd.setShortHeadline("Travel");
  responsiveDisplayAd.setLongHeadline("Travel the World");
  responsiveDisplayAd.setDescription("Take to the air!");
  responsiveDisplayAd.setBusinessName("Interplanetary Cruises");
  responsiveDisplayAd.setFinalUrls(new String[] {"http://www.example.com/"});

  // Optional: Create a square marketing image using MediaService, and set it
  // to the ad.
  long squareMarketingImageMediaId = uploadImage(mediaService, "https://goo.gl/mtt54n");
  Image squareMarketingImage = new Image();
  squareMarketingImage.setMediaId(squareMarketingImageMediaId);
  responsiveDisplayAd.setSquareMarketingImage(squareMarketingImage);

  // Optional: set call to action text.
  responsiveDisplayAd.setCallToActionText("Shop Now");

  // Optional: Set dynamic display ad settings, composed of landscape logo
  // image, promotion text, and price prefix.
  DynamicSettings dynamicDisplayAdSettings = createDynamicDisplayAdSettings(mediaService);
  responsiveDisplayAd.setDynamicDisplayAdSettings(dynamicDisplayAdSettings);

  // Whitelisted accounts only: Set color settings using hexadecimal values.
  // Set allowFlexibleColor to false if you want your ads to render by always
  // using your colors strictly.
  /*
  responsiveDisplayAd.setMainColor("#0000ff");
  responsiveDisplayAd.setAccentColor("#ffff00");
  responsiveDisplayAd.setAllowFlexibleColor(false);
  */

  // Whitelisted accounts only: Set the format setting that the ad will be
  // served in.
  /*
  responsiveDisplayAd.setFormatSetting(
      com.google.api.ads.adwords.axis.v201708.cm.DisplayAdFormatSetting.NON_NATIVE);
  */

  // Create ad group ad for the responsive display ad.
  AdGroupAd adGroupAd = new AdGroupAd();
  adGroupAd.setAdGroupId(adGroupId);
  adGroupAd.setAd(responsiveDisplayAd);

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

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

  // Make the mutate request.
  AdGroupAdReturnValue result =
      adGroupAdService.mutate(new AdGroupAdOperation[] {adGroupAdOperation});

  // Display ads.
  for (AdGroupAd adGroupAdResult : result.getValue()) {
    ResponsiveDisplayAd newAd = (ResponsiveDisplayAd) adGroupAdResult.getAd();
    System.out.printf(
        "Responsive display ad with ID %d and short headline '%s' was added.%n",
        newAd.getId(), newAd.getShortHeadline());
  }
}

private static DynamicSettings createDynamicDisplayAdSettings(MediaServiceInterface mediaService)
    throws IOException {
  long logoImageMediaId = uploadImage(mediaService, "https://goo.gl/dEvQeF");
  Image logo = new Image();
  logo.setMediaId(logoImageMediaId);

  DynamicSettings dynamicSettings = new DynamicSettings();
  dynamicSettings.setLandscapeLogoImage(logo);
  dynamicSettings.setPricePrefix("as low as");
  dynamicSettings.setPromoText("Free shipping!");
  return dynamicSettings;
}

/**
 * Uploads the image from the specified {@code url} via {@code MediaService}.
 *
 * @return the {@code mediaId} of the uploaded image.
 */
private static long uploadImage(MediaServiceInterface mediaService, String url)
    throws IOException {
  // Create image.
  Image image = new Image();
  image.setType(MediaMediaType.IMAGE);
  image.setData(com.google.api.ads.common.lib.utils.Media.getMediaDataFromUrl(url));

  // Upload image.
  Image uploadedImage = (Image) mediaService.upload(new Media[] {image})[0];
  return uploadedImage.getMediaId();
}

Visual Basic

' Get the AdGroupAdService.
Dim adGroupAdService As AdGroupAdService = CType(user.GetService(
    AdWordsService.v201708.AdGroupAdService), AdGroupAdService)

Try
  ' Create a responsive display ad.
  Dim responsiveDisplayAd As New ResponsiveDisplayAd()

  ' This ad format does not allow the creation of an image using the
  ' Image.data field. An image must first be created using the MediaService,
  ' and Image.mediaId must be populated when creating the ad.
  responsiveDisplayAd.marketingImage = New Image()
  responsiveDisplayAd.marketingImage.mediaId = UploadImage(user, "https://goo.gl/3b9Wfh")

  responsiveDisplayAd.shortHeadline = "Travel"
  responsiveDisplayAd.longHeadline = "Travel the World"
  responsiveDisplayAd.description = "Take to the air!"
  responsiveDisplayAd.businessName = "Google"
  responsiveDisplayAd.finalUrls = New String() {"http://www.example.com"}

  ' Optional Create a square marketing image Using MediaService, And set it
  ' to the ad.
  responsiveDisplayAd.squareMarketingImage = New Image()
  responsiveDisplayAd.squareMarketingImage.mediaId =
      UploadImage(user, "https://goo.gl/mtt54n")

  ' Optional set call to action text.
  responsiveDisplayAd.callToActionText = "Shop Now"

  ' Optional Set dynamic display ad settings, composed of landscape logo
  ' image, promotion text, And price prefix.
  responsiveDisplayAd.dynamicDisplayAdSettings = CreateDynamicDisplayAdSettings(user)

  ' Whitelisted accounts only Set color settings using hexadecimal values.
  ' Set allowFlexibleColor to false if you want your ads to render by always
  ' using your colors strictly.

  ' responsiveDisplayAd.mainColor = "#0000ff"
  ' responsiveDisplayAd.accentColor = "#ffff00"
  ' responsiveDisplayAd.allowFlexibleColor = false

  ' Whitelisted accounts only Set the format setting that the ad will be
  ' served in.

  ' responsiveDisplayAd.formatSetting = DisplayAdFormatSetting.NON_NATIVE;

  ' Create ad group ad.
  Dim adGroupAd As New AdGroupAd()
  adGroupAd.adGroupId = adGroupId
  adGroupAd.ad = responsiveDisplayAd
  adGroupAd.status = AdGroupAdStatus.PAUSED

  ' Create operation.
  Dim operation As New AdGroupAdOperation()
  operation.operand = adGroupAd
  operation.operator = [Operator].ADD

  ' Make the mutate request.
  Dim result As AdGroupAdReturnValue = adGroupAdService.mutate(
      New AdGroupAdOperation() {operation})

  ' Display results.
  If (Not result Is Nothing) AndAlso (Not result.value Is Nothing) Then
    For Each newAdGroupAd As AdGroupAd In result.value
      Dim newAd As ResponsiveDisplayAd = CType(newAdGroupAd.ad, ResponsiveDisplayAd)
      Console.WriteLine("Responsive display ad with ID '{0}' and short headline '{1}'" &
          " was added.", newAd.id, newAd.shortHeadline)
    Next
  Else
    Console.WriteLine("No responsive display ads were created.")
  End If
Catch e As Exception
  Throw New System.ApplicationException("Failed to create responsive display ads.", e)
End Try

Python

def main(client, ad_group_id):
  # Initialize appropriate services.
  ad_group_ad_service = client.GetService('AdGroupAdService', version='v201708')
  media_service = client.GetService('MediaService', version='v201708')
  opener = urllib2.build_opener(*client.proxy_config.GetHandlers())

  try:
    # Create marketing image.
    marketing_image = _CreateImage(media_service, opener,
                                   'https://goo.gl/3b9Wfh')

    # Create square marketing image.
    square_marketing_image = _CreateImage(media_service, opener,
                                          'https://goo.gl/mtt54n')

    # Create a responsive display ad.
    operations = [{
        'operator': 'ADD',
        'operand': {
            'xsi_type': 'AdGroupAd',
            'adGroupId': ad_group_id,
            'ad': {
                'xsi_type': 'ResponsiveDisplayAd',
                'marketingImage': {'mediaId': marketing_image['mediaId']},
                'shortHeadline': 'Travel',
                'longHeadline': 'Travel the World',
                'description': 'Take to the air!',
                'businessName': 'Interplanetary Cruises',
                'finalUrls': ['http://www.example.com'],
                # Optional: Set a square marketing image to the ad.
                'squareMarketingImage': {
                    'mediaId': square_marketing_image['mediaId']
                },
                # Optional: Set call-to-action text.
                'callToActionText': 'Shop Now',
                # Optional: Set dynamic display ad settings, composed of
                # landscape logo image, promotion text, and price prefix.
                'dynamicDisplayAdSettings': _CreateDynamicDisplayAdSettings(
                    media_service, opener),
                # Whitelisted accounts only: Set color settings using
                # hexadecimal numbers.
                # Set allowFlexibleColor to False if you want your ads to render
                # by always using your colors strictly.
                # 'mainColor': '#0000ff',
                # 'accentColor': '#ffff00',
                # 'allowFlexibleColor': False
                # Whitelisted accounts only: Set the format setting that the ad
                # will be served in.
                # 'formatSetting': 'NON_NATIVE'

            },
            # Optional fields.
            'status': 'PAUSED'
        }
    }]

    # Make the mutate request.
    ads = ad_group_ad_service.mutate(operations)

    # Display results.
    for ad in ads['value']:
      print ('ResponsiveDisplayAd with id "%d" and short headline "%s" was '
             'added.' % (ad['ad']['id'], ad['ad']['shortHeadline']))

  except:
    raise Exception('Failed to create responsive display ad.')


def _CreateImage(media_service, opener, url):
  """Creates an image and uploads it to the server.

  Args:
    media_service: a SudsServiceProxy instance for AdWords's MediaService.
    opener: an OpenerDirector instance.
    url: a str URL used to load image data.

  Returns:
    The image that was successfully uploaded.
  """
  image_data = base64.b64encode(opener.open(url).read())
  image = {
      'type': 'IMAGE',
      'data': image_data,
      'xsi_type': 'Image'
  }

  return media_service.upload(image)[0]


def _CreateDynamicDisplayAdSettings(media_service, opener):
  """Creates settings for dynamic display ad.

  Args:
    media_service: a SudsServiceProxy instance for AdWords's MediaService.
    opener: an OpenerDirector instance.

  Returns:
    The dynamic display ad settings.
  """
  image = _CreateImage(media_service, opener, 'https://goo.gl/dEvQeF')

  logo = {
      'type': 'IMAGE',
      'mediaId': image['mediaId'],
      'xsi_type': 'Image'
  }

  dynamic_settings = {
      'landscapeLogoImage': logo,
      'pricePrefix': 'as low as',
      'promoText': 'Free shipping!',
      'xsi_type': 'DynamicSettings',
  }

  return dynamic_settings

PHP

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

  $operations = [];
  // Create a responsive display ad.
  $responsiveDisplayAd = new ResponsiveDisplayAd();

  // This ad format does not allow the creation of an image using the
  // Image.data field. An image must first be created using the MediaService,
  // and Image.mediaId must be populated when creating the ad.
  $adImage = self::uploadImage($mediaService, 'http://goo.gl/3b9Wfh');
  $marketingImage = new Image();
  $marketingImage->setMediaId($adImage->getMediaId());
  $responsiveDisplayAd->setMarketingImage($marketingImage);

  $responsiveDisplayAd->setShortHeadline('Travel');
  $responsiveDisplayAd->setLongHeadline('Travel the World');
  $responsiveDisplayAd->setDescription('Take to the air!');
  $responsiveDisplayAd->setBusinessName('Google');
  $responsiveDisplayAd->setFinalUrls(['http://www.example.com']);

  // Optional: Create a square marketing image using MediaService, and set it
  // to the ad.
  $squareImage = self::uploadImage($mediaService, 'https://goo.gl/mtt54n');
  $squareMarketingImage = new Image();
  $squareMarketingImage->setMediaId($squareImage->getMediaId());
  $responsiveDisplayAd->setSquareMarketingImage($squareMarketingImage);

  // Optional: Set call to action text.
  $responsiveDisplayAd->setCallToActionText('Shop Now');

  // Optional: Set dynamic display ad settings, composed of landscape logo
  // image, promotion text, and price prefix.
  $dynamicSettings = self::createDynamicDisplayAdSettings($mediaService);
  $responsiveDisplayAd->setDynamicDisplayAdSettings($dynamicSettings);

  // Whitelisted accounts only: Set color settings using hexadecimal values.
  // Set allowFlexibleColor to false if you want your ads to render by always
  // using your colors strictly.
  /*
  $responsiveDisplayAd->setMainColor('#0000ff');
  $responsiveDisplayAd->setAccentColor('#ffff00');
  $responsiveDisplayAd->setAllowFlexibleColor(false);
  */

  // Whitelisted accounts only: Set the format setting that the ad will be
  // served in.
  /*
  $responsiveDisplayAd->setFormatSetting(DisplayAdFormatSetting::NON_NATIVE);
  */

  // Create ad group ad.
  $adGroupAd = new AdGroupAd();
  $adGroupAd->setAdGroupId($adGroupId);
  $adGroupAd->setAd($responsiveDisplayAd);
  // 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 a responsive display ad on the server.
  $result = $adGroupAdService->mutate($operations);

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

private static function uploadImage(MediaService $mediaService, $url) {
  // Creates an image and upload it to the server.
  $image = new Image();
  $image->setData(file_get_contents($url));
  $image->setType(MediaMediaType::IMAGE);

  return $mediaService->upload([$image])[0];
}

private static function createDynamicDisplayAdSettings(
    MediaService $mediaService) {
  $logoImage = self::uploadImage($mediaService, 'https://goo.gl/dEvQeF');
  $logo = new Image();
  $logo->setMediaId($logoImage->getMediaId());

  $dynamicSettings = new DynamicSettings();
  $dynamicSettings->setLandscapeLogoImage($logo);
  $dynamicSettings->setPricePrefix('as low as');
  $dynamicSettings->setPromoText('Free shipping!');

  return $dynamicSettings;
}

Perl

sub add_responsive_display_ad {
  my ($client, $ad_group_id) = @_;

  # This ad format does not allow the creation of an image using the
  # Image.data field. An image must first be created using the MediaService,
  # and Image.mediaId must be populated when creating the ad.
  my $ad_image = _upload_image($client, "http://goo.gl/3b9Wfh");
  my $marketing_image = Google::Ads::AdWords::v201708::Image->new(
    {mediaId => $ad_image->get_mediaId()});

  # Create the responsive display ad.
  my $responsive_display_ad =
    Google::Ads::AdWords::v201708::ResponsiveDisplayAd->new({
      marketingImage => $marketing_image,
      shortHeadline  => "Travel",
      longHeadline   => "Travel the World",
      description    => "Take to the air!",
      businessName   => "Interplanetary Cruises",
      finalUrls      => ["http://www.example.com/"],
    });

  # Optional: Create a square marketing image using MediaService, and set it
  # to the ad.
  my $square_image = _upload_image($client, "https://goo.gl/mtt54n");
  my $square_marketing_image = Google::Ads::AdWords::v201708::Image->new(
    {mediaId => $square_image->get_mediaId()});
  $responsive_display_ad->set_squareMarketingImage($square_marketing_image);

  # Optional: Set call to action text.
  $responsive_display_ad->set_callToActionText("Shop Now");

  # Optional: Set dynamic display ad settings, composed of landscape logo
  # image, promotion text, and price prefix.
  my $dynamic_settings = _create_dynamic_display_ad_settings($client);
  $responsive_display_ad->set_dynamicDisplayAdSettings($dynamic_settings);

  # Whitelisted accounts only: Set color settings using hexadecimal values.
  # Set allowFlexibleColor to false if you want your ads to render by always
  # using your colors strictly.
  # $responsiveDisplayAd->set_mainColor("#0000ff");
  # $responsiveDisplayAd->set_accentColor("#ffff00");
  # $responsiveDisplayAd->set_allowFlexibleColor(0);

  # Whitelisted accounts only: Set the format setting that the ad will be
  # served in.
  # $responsiveDisplayAd->set_formatSetting("NON_NATIVE");

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

  # Create operation.
  my $responsive_display_ad_group_ad_operation =
    Google::Ads::AdWords::v201708::AdGroupAdOperation->new({
      operator => "ADD",
      operand  => $responsive_display_ad_group_ad
    });

  # Add responsive display ad.
  my $result =
    $client->AdGroupAdService()
    ->mutate({operations => [$responsive_display_ad_group_ad_operation]});

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

  return 1;
}

sub _upload_image {
  my ($client, $url) = @_;

  # Creates an image and upload it to the server.
  my $image_data = Google::Ads::Common::MediaUtils::get_base64_data_from_url(
    $url);
  my $image = Google::Ads::AdWords::v201708::Image->new({
      data => $image_data,
      type => "IMAGE"
  });

  return $client->MediaService()->upload({media => [$image]});
}

sub _create_dynamic_display_ad_settings {
  my ($client) = @_;

  my $logo_image = _upload_image($client, 'https://goo.gl/dEvQeF');
  my $logo = Google::Ads::AdWords::v201708::Image->new({
      mediaId => $logo_image->get_mediaId(),
  });

  my $dynamic_settings = Google::Ads::AdWords::v201708::DynamicSettings->new({
    landscapeLogoImage => $logo,
    pricePrefix => "as low as",
    promoText => "Free shipping!"
  });

  return $dynamic_settings;
}

Ruby

def add_responsive_display_ad(adwords, ad_group_id)
  ad_group_ad_srv = adwords.service(:AdGroupAdService, API_VERSION)

  # This ad format does not allow the creation of an image using the Image.data
  # field. An image must first be created using the MediaService, and
  # Image.mediaId must be populated when creating the ad.
  ad_image = upload_image(adwords, 'https://goo.gl/3b9Wfh')

  # Create the responsive display ad.
  responsive_display_ad = {
    :xsi_type => 'ResponsiveDisplayAd',
    # This ad format does not allow the creation of an image using the
    # Image.data field. An image must first be created using the MediaService,
    # and Image.mediaId must be populated when creating the ad.
    :marketing_image => {:media_id => ad_image[:media_id]},
    :short_headline => 'Travel',
    :long_headline => 'Traver the World',
    :description => 'Take to the air!',
    :business_name => 'Interplanetary Cruises',
    :final_urls => ['http://www.example.com/'],

    # Optional: Set call to action text.
    :call_to_action_text => 'Shop Now'

    # Whitelisted accounts only: Set color settings using hexadecimal values.
    # Set 'allow_flexible_color' to false if you want your ads to render by
    # always using your colors strictly.
    #:main_color => '#0000ff',
    #:accent_color => '#ffff00',
    #:allow_flexible_color => false,

    # Whitelisted accounts only: Set the format setting that the ad will be
    # served in.
    #:format_setting => 'NON_NATIVE'
  }

  # Optional: Create a square marketing image using MediaService, and set it to
  # the ad.
  square_image = upload_image(adwords, 'https://goo.gl/mtt54n')
  responsive_display_ad[:square_marketing_image] = {
    :media_id => square_image[:media_id]
  }

  # Optional: Set dynamic display ad settings, composed of landscape logo image,
  # promotion text, and price prefix.
  logo_image = upload_image(adwords, 'https://goo.gl/dEvQeF')
  responsive_display_ad[:dynamic_display_ad_settings] = {
    :landscape_logo_image => {:media_id => logo_image[:media_id]},
    :price_prefix => 'as low as',
    :promo_text => 'Free shipping!'
  }

  # Create an ad group ad for the responsive display ad.
  responsive_display_ad_group_ad = {
    :ad_group_id => ad_group_id,
    :ad => responsive_display_ad,
    # Additional propertires (non-required).
    :status => 'PAUSED'
  }

  # Create operation.
  responsive_display_ad_group_ad_operations = {
    :operator => 'ADD',
    :operand => responsive_display_ad_group_ad
  }

  # Add the responsive display ad.
  result = ad_group_ad_srv.mutate([responsive_display_ad_group_ad_operations])

  # Display results.
  if result && result[:value]
    result[:value].each do |ad_group_ad|
      puts ("New responsive display ad with id %d and short headline '%s' was" +
          "added.") % [ad_group_ad[:ad][:id], ad_group_ad[:ad][:short_headline]]
    end
  else
    puts 'No responsive display ads were added.'
  end
end

def upload_image(adwords, image_url)
  media_srv = adwords.service(:MediaService, API_VERSION)

  # Create an image.
  raw_image_data = AdsCommon::Http.get(image_url, adwords.config)
  image = {
    :xsi_type => 'Image',
    :data => Base64.encode64(raw_image_data),
    :type => 'IMAGE'
  }

  # Upload the image.
  response = media_srv.upload([image])
  if response and !response.empty?
    return response.first
  else
    raise StandardError, 'Could not upload image, aborting.'
  end
end

Responsive ads can run only in campaigns targeting the Google Display Network. Make sure you have an advertisingChannelType of DISPLAY set on the campaign. In the AdWords user interface, the campaign will be described as Display Network Only -- All Features.

Whitelist-only features

The following features are available only to whitelisted customers:

Color controls
You can customize colors for your responsive display ads to fit your branding needs by specifying mainColor and accentColor. Set allowFlexibleColor to true when you want to allow for serving ads with different colors than what you've specified when necessary.
Display ad format setting

Responsive ads can run as both native and non-native formats. The difference between these two formats are that native format rendering is controlled by publishers, whereas non-native format rendering is optimized by Google models with advertisers' inputs (e.g., color information from mainColor and accentColor).

You can set the formatSetting field to select the format that the ads should run as. However, you cannot set the formatSetting to NATIVE when the allowFlexibleColor is false, as the coloring needs to be controlled by publishers in the case of native formats.

Specifications

The marketing image and the logo image must meet the following dimension and size specifications:

  • Marketing image

    • Minimum dimensions: 600x314 pixels

    • Greater than minimum dimensions: Within 1% of the 1.91:1 ratio

    • Suggested dimensions: 1200x628 pixels

    • Maximum size: 1MB (1,048,576 bytes)

  • Logo image (Optional)

    • Minimum dimensions: 128x128 pixels

    • Greater than minimum dimensions: Within 1% of the 1:1 ratio

    • Suggested dimensions: 1200x1200 pixels

    • Maximum size: 1MB (1,048,576 bytes)

  • Landscape logo image

    • Minimum dimensions: 512x128 pixels

    • Greater than minimum dimensions: Within 1% of the 4:1 ratio

    • Suggested dimensions: 1200x300 pixels

    • Maximum size: 1MB (1,048,576 bytes)

  • Square marketing image

    • Minimum dimensions: 300x300 pixels

    • Greater than minimum dimensions: Within 1% of the 1:1 ratio

    • Suggested dimensions: 1200x1200 pixels

    • Maximum size: 1MB (1,048,576 bytes)

Reporting

The AdType in reports for responsive ads is RESPONSIVE_DISPLAY_AD.

The AD_PERFORMANCE_REPORT contains the following fields specific to responsive ads:

Upgrade tips

You can test the new ad format in test accounts today. Perform the following steps if you're upgrading from standard text ads to responsive ads for Display:

  1. Create the new responsive ad in a PAUSED state.

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

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

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

Check out the Generate custom display ads based on your text ads section under Tips for creating effective display ads for more general tips.

Code examples

Send feedback about...

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