Responsive Anzeigen für das Displaynetzwerk

Eine responsive Anzeige für das Displaynetzwerk ist eine Anzeige, deren Größe, Design und Format automatisch angepasst wird, damit sie in die jeweilige Werbefläche passt.

ResponsiveDisplayAd enthält die folgenden Elemente:

  • Kurzer Anzeigentitel
  • Langer Anzeigentitel
  • Beschreibung
  • Name des Unternehmens
  • Marketingbild
  • Quadratische und andere Marketingbilder
  • Call-to-Action-Text (optional)
  • Logo (optional)
  • Werbeaktionstext (optional)
  • Preispräfix (optional)

Weitere Informationen zu diesen Feldern

Beispiel

Sie erstellen responsive Anzeigen in zwei Schritten:

  1. Laden Sie Marketingbild, optionales Logo, Logo im Querformat und quadratisches Marketingbild mithilfe von MediaService mit der upload()-Methode hoch. Merken Sie sich die zurückgegebene ID. Diese brauchen Sie, wenn Sie die Anzeige hinzufügen. Optional kann ein Logobild auf die gleiche Weise hochgeladen werden. Wenn ein Bild über MediaService hochgeladen wurde, kann es später für mehrere Anzeigen verwendet werden.

  2. Erstellen Sie ein ResponsiveDisplayAd mit AdGroupAdService. Verweisen Sie in den Feldern marketingImage, logoImage, landscapeLogoImage und squareMarketingImage auf die Medien-IDs, die im ersten Schritt zurückgegeben wurden.

Im nachfolgenden Beispiel sehen Sie, wie einer Kampagne, die auf das Displaynetzwerk ausgerichtet ist, ein Bild hinzugefügt wird. Dieses Bild für Interplanetary Cruises erfüllt die Spezifikationen für Bilder in responsiven Anzeigen:

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.v201802.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

Using adGroupAdService As AdGroupAdService = CType(user.GetService(
    AdWordsService.v201802.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='v201802')
  media_service = client.GetService('MediaService', version='v201802')
  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.
  """
  # 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 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::v201802::Image->new(
    {mediaId => $ad_image->get_mediaId()});

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

  my $dynamic_settings = Google::Ads::AdWords::v201802::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 Anzeigen können nur in Kampagnen mit Ausrichtung auf das Google Displaynetzwerk bereitgestellt werden. Achten Sie darauf, dass advertisingChannelType für die Kampagne auf DISPLAYNETZWERK festgelegt ist. Auf der AdWords-Benutzeroberfläche entspricht dies dem Kampagnentyp Nur Displaynetzwerk – Alle Funktionen.

Funktionen, die nicht generell verfügbar sind

Die folgenden Funktionen werden nur für bestimmte Kunden aktiviert:

Steuerelemente für Farben
Sie können die Farben für Ihre responsiven Displaynetzwerk-Anzeigen mit mainColor und accentColor an Ihre Brandinganforderungen anpassen. Legen Sie allowFlexibleColor auf true fest, wenn Sie Anzeigen in anderen Farben als angegeben ausliefern möchten.
Einstellung für das Format von Displaynetzwerk-Anzeigen

Responsive Anzeigen können sowohl ein natives als auch ein anderes Format haben. Der Unterschied zwischen diesen beiden Formaten ist, dass das Rendering für native Anzeigen vom Publisher bestimmt wird. Bei anderen Anzeigen wird das Rendering durch Google-Modelle optimiert und basiert auf den Eingaben der Werbetreibenden (z. B. Farbinformationen aus mainColor und accentColor).

Sie können das Feld formatSetting festlegen, um das Format für die Anzeigen auszuwählen. Wenn allowFlexibleColor auf false eingestellt ist, kann formatSetting nicht auf NATIVE festgelegt werden, da die Farbanforderungen bei nativen Formaten von Publishern bestimmt werden.

Spezifikationen

Für das Marketingbild und das Logobild müssen die folgenden Spezifikationen für Abmessung und Größe erfüllt sein:

  • Marketingbild

    • Mindestabmessungen: 600 x 314 Pixel

    • Größer als Mindestabmessungen: innerhalb von 1 % des 1,91 : 1-Verhältnisses

    • Empfohlene Abmessungen: 1.200 x 628 Pixel

    • Maximale Größe: 1 MB (1.048.576 Byte)

  • Logobild (optional)

    • Mindestabmessungen: 128 x 128 Pixel

    • Größer als Mindestabmessungen: innerhalb von 1 % des 1 : 1-Verhältnisses

    • Empfohlene Abmessungen: 1.200 x 1.200 Pixel

    • Maximale Größe: 1 MB (1.048.576 Byte)

  • Logobild im Querformat

    • Mindestabmessungen: 512 x 128 Pixel

    • Größer als Mindestabmessungen: innerhalb von 1 % des 4 : 1-Verhältnisses

    • Empfohlene Abmessungen: 1.200 x 300 Pixel

    • Maximale Größe: 1 MB (1.048.576 Byte)

  • Quadratisches Marketingbild

    • Mindestabmessungen: 300 x 300 Pixel

    • Größer als Mindestabmessungen: innerhalb von 1 % des 1 : 1-Verhältnisses

    • Empfohlene Abmessungen: 1.200 x 1.200 Pixel

    • Maximale Größe: 1 MB (1.048.576 Byte)

Berichte

Der AdType in Berichten zu responsiven Anzeigen ist RESPONSIVE_DISPLAY_AD.

Der AD_PERFORMANCE_REPORT enthält die folgenden Felder speziell für responsive Anzeigen:

Tipps zur Umstellung

Sie können das neue Anzeigenformat schon jetzt in Testkonten testen. Führen Sie die folgenden Schritte aus, wenn Sie Standardtextanzeigen auf responsive Anzeigen für das Displaynetzwerk umstellen möchten:

  1. Erstellen Sie die neue responsive Anzeige im Status PAUSIERT.

  2. Warten Sie, bis der approvalStatus der neuen responsiven Anzeige FREIGEGEBEN ist.

  3. Senden Sie eine AdGroupAdService.mutate()-Anfrage mit zwei Vorgängen:

    • Legen Sie den status der neuen responsiven Anzeige auf AKTIVIERT fest.
    • Legen Sie den status der bisherigen Standardtextanzeige auf DEAKTIVIERT fest.

Allgemeinere Tipps finden Sie im Abschnitt Benutzerdefinierte Anzeigen im Displaynetzwerk auf der Grundlage von Textanzeigen erstellen unter Tipps für ansprechende Displaynetzwerk-Anzeigen.

Codebeispiele

Feedback geben zu...