Anúncios responsivos para a Rede de Display

Os anúncios responsivos para a Rede de Display são aqueles que se ajustam automaticamente em termos de tamanho, aparência e formato para caber nos espaços disponíveis na Rede de Display do Google.

Um ResponsiveDisplayAd contém os seguintes elementos:

  • título curto
  • título longo
  • descrição
  • nome da empresa
  • imagem de marketing
  • logotipo no modo paisagem e imagens de marketing quadradas
  • texto de call-to-action (opcional)
  • logotipo (opcional)
  • texto de promoção (opcional)
  • prefixo de preço (opcional)

Leia mais sobre esses campos.

Exemplo

Os anúncios responsivos são criados em duas etapas:

  1. Faça o upload da imagem de marketing, do logotipo opcional, do logotipo no modo paisagem e as imagens de marketing quadradas usando o MediaService com o método upload(). Acompanhe o ID retornado. Você precisará dele mais tarde ao adicionar seu anúncio. Se quiser, poderá fazer o upload de uma imagem de logotipo da mesma maneira. Quando uma imagem é carregada por meio do serviço de mídia, ela pode ser reutilizada depois para vários anúncios.

  2. Crie um ResponsiveDisplayAd usando o AdGroupAdService. Para o marketingImage, logoImage, landscapeLogoImage e squareMarketingImage, insira os IDs de mídia que foram retornados na primeira fase.

Agora vejamos um exemplo de adição de uma imagem a uma campanha que segmenta a Rede de Display. Veja uma imagem de exemplo para Cruzeiros Interplanetários, que satisfaz as especificações de imagens em anúncios responsivos.

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

Os anúncios responsivos só podem ser exibidos em campanhas que segmentam a Rede de Display do Google. Verifique se você tem um advertisingChannelType do conjunto DISPLAY definido na campanha. Na interface do usuário do Google AdWords, a campanha é descrita como Apenas na Rede de Display – todos os recursos.

Recursos exclusivos da lista de permissões

Os recursos a seguir estão disponíveis somente para clientes colocados na lista de permissões:

Controles de cor
Você pode personalizar as cores dos seus anúncios gráficos responsivos para atender às suas necessidades de marca especificando mainColor e accentColor. Defina allowFlexibleColor como true quando você quiser permitir a veiculação de anúncios com cores diferentes das que você especificou.
Configuração de formato de anúncio gráfico

Os anúncios responsivos podem ser executados como formatos nativos e não nativos. A diferença entre esses dois formatos é que a renderização de formato nativo é controlada pelos editores, enquanto a renderização de formato não nativo é otimizada pelos modelos do Google com entradas de anunciantes (por exemplo, informações de cor de mainColor e accentColor).

Você pode definir o campo formatSetting para selecionar o formato com o qual os anúncios devem ser executados. No entanto, você não pode definir a formatSetting como NATIVE quando allowFlexibleColor for false porque a coloração precisa ser controlada pelos editores no caso de formatos nativos.

Especificações

A imagem de marketing e a imagem do logotipo precisam atender às seguintes especificações de dimensão e tamanho:

  • Imagem de marketing

    • Dimensões mínimas: 600 x 314 pixels

    • Maior do que as dimensões mínimas: dentro de 1% da proporção 1,91:1

    • Dimensões sugeridas: 1.200 x 628 pixels

    • Tamanho máximo: 1 MB (1.048.576 bytes)

  • Imagem do logotipo (opcional)

    • Dimensões mínimas: 128 x 128 pixels

    • Maior do que as dimensões mínimas: dentro de 1% da proporção 1:1

    • Dimensões sugeridas: 1.200 x 1.200 pixels

    • Tamanho máximo: 1 MB (1.048.576 bytes)

  • Imagem de logotipo no modo paisagem

    • Dimensões mínimas: 512 x 128 pixels

    • Maior do que as dimensões mínimas: dentro de 1% da proporção 4:1

    • Dimensões sugeridas: 1.200 x 300 pixels

    • Tamanho máximo: 1 MB (1.048.576 bytes)

  • Imagem de marketing quadrada

    • Dimensões mínimas: 300 x 300 pixels

    • Maior do que as dimensões mínimas: dentro de 1% da proporção 1:1

    • Dimensões sugeridas: 1.200 x 1.200 pixels

    • Tamanho máximo: 1 MB (1.048.576 bytes)

Relatórios

O AdType em relatórios para anúncios responsivos é RESPONSIVE_DISPLAY_AD.

O AD_PERFORMANCE_REPORT contém os seguintes campos específicos para anúncios responsivos:

Dicas de upgrade

Você pode testar o novo formato de anúncio em contas de teste hoje mesmo. Execute as seguintes etapas se estiver fazendo upgrade de anúncios de texto padrão para anúncios responsivos da Rede de Display:

  1. Crie o novo anúncio responsivo em um estado PAUSADO.

  2. Aguarde até que o approvalStatus do novo anúncio responsivo se torne APROVADO.

  3. Envie uma solicitação AdGroupAdService.mutate() com duas operações:

    • Defina o status do novo anúncio responsivo como ATIVADO.
    • Defina o status do antigo anúncio de texto padrão como DESATIVADO.

Confira a seção Gere anúncios gráficos personalizados com base em seus anúncios de texto em Dicas para criar anúncios gráficos eficazes para ver outras dicas gerais.

Exemplos de código

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.