Google Ads

Responsive Ads for Display  |  AdWords API  |  Google Developers

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.

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

/**
 * Runs the example.
 *
 * @param adWordsServices the services factory.
 * @param session the session.
 * @param adGroupId the ID of the ad group where the ad will be created.
 * @throws ApiException if the API request failed with one or more service errors.
 * @throws RemoteException if the API request failed due to other errors.
 * @throws IOException if uploading an image failed.
 */
public static void runExample(
    AdWordsServicesInterface adWordsServices, AdWordsSession session, long adGroupId)
    throws IOException {
  // 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.v201809.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.
  Arrays.stream(result.getValue())
      .map(adGroupAdResult -> (ResponsiveDisplayAd) adGroupAdResult.getAd())
      .forEach(
          newAd ->
              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

Using adGroupAdService As AdGroupAdService = CType(
    user.GetService(
        AdWordsService.v201809.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
End Using

Python

def main(client, ad_group_id):
  # Initialize appropriate services.
  ad_group_ad_service = client.GetService('AdGroupAdService', version='v201809')
  media_service = client.GetService('MediaService', version='v201809')
  opener = 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 ZeepServiceProxy 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.
  """
  # Note: The utf-8 decode is for 2to3 Python 3 compatibility.
  image_data = opener.open(url).read().decode('utf-8')
  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 ZeepServiceProxy 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::v201809::Image->new(
    {mediaId => $ad_image->get_mediaId()});

  # Create the responsive display ad.
  my $responsive_display_ad =
    Google::Ads::AdWords::v201809::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::v201809::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::v201809::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::v201809::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::v201809::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::v201809::Image->new({
      mediaId => $logo_image->get_mediaId(),
  });

  my $dynamic_settings = Google::Ads::AdWords::v201809::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 Google Ads UI, the
campaign will be described as Display Network Only — All Features.

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:

Leave a Reply

Your email address will not be published. Required fields are marked *

Back to top button
Close