Modificatori di offerta

I modificatori di offerta ti consentono di modificare le offerte per un criterio specifico senza modificare il targeting della campagna o del gruppo di annunci. Ad esempio, un modificatore di offerta per gruppo di annunci per i dispositivi mobili non esclude le impressioni per altri tipi di dispositivi, ma ti consente di aumentare o diminuire le offerte per le impressioni sui dispositivi mobili.

I modificatori vengono impostati come moltiplicatori a virgola mobile nel campo bid_modifier. Ad esempio, un valore di 1.2 aumenta un'offerta del 20%, mentre 0.8 la diminuisce del 20%. Per i criteri supportati (ad esempio l'esclusione di un tipo di dispositivo), un valore di 0.0 (equivalente a un aggiustamento delle offerte del -100% nell'interfaccia utente di Google Ads) disattiva il criterio. Quando a un'impressione vengono applicati più modificatori di offerta, questi vengono moltiplicati tra loro per calcolare l'aggiustamento delle offerte finale. Per gli intervalli di valori validi, consulta la documentazione di riferimento di CampaignBidModifier e AdGroupBidModifier.

Per saperne di più su come funzionano le offerte e su come impostare i modificatori di offerta, consulta le guide Panoramica delle offerte e Gestire i modificatori di offerta.

Nota: se la tua campagna utilizza Smart Bidding (ad esempio CPA target o ROAS target), i modificatori di offerta si comportano in modo diverso o potrebbero essere ignorati a seconda del tipo di strategia. Ad esempio, i modificatori di offerta per dispositivo con CPA target modificano il CPA target anziché l'offerta stessa.

Modificatori di offerta delle campagne

Puoi specificare i modificatori di offerta a livello di campagna per il seguente tipo di criterio utilizzando CampaignBidModifierService:

InteractionTypeInfo

Definisci InteractionTypeInfo criteri utilizzando una delle enumerazioni predefinite InteractionType. CALL è l'unico valore di enumerazione supportato per i modificatori di offerta delle campagne. Se specifichi un altro valore, viene restituito un CriterionError.

Modificatori di offerta per gruppo di annunci

Puoi specificare i modificatori di offerta a livello di gruppo di annunci per i seguenti tipi di criteri utilizzando AdGroupBidModifierService:

DeviceInfo

Definisci i criteri DeviceInfo utilizzando una delle enumerazioni predefinite Device.

Vari criteri di viaggio

Nella versione 26 e successive, imposta i modificatori per i criteri relativi agli itinerari di viaggio utilizzando criteri indipendenti dal verticale: UserSetDatesInfo, AdvanceBookingWindowInfo, LengthOfBookingInfo, StartDayOfWeekInfo e StartDateRangeInfo. Nella versione 25 e precedenti, imposta i modificatori specifici per gli hotel per HotelDateSelectionTypeInfo, HotelAdvanceBookingWindowInfo, HotelLengthOfStayInfo, HotelCheckInDayInfo e HotelCheckInDateRangeInfo. Per maggiori dettagli, consulta la guida ai modificatori di offerta degli annunci per hotel.

Modificatori di offerta a livello di criterio

Oltre ai servizi di modificatori di offerta dedicati, alcuni criteri impostati sulle CampaignCriterion o AdGroupCriterion risorse supportano l'impostazione diretta di un bid_modifier campo (CampaignCriterion.bid_modifier o AdGroupCriterion.bid_modifier, ad esempio per i criteri relativi a località, pianificazione degli annunci o dati demografici).

Nota: a partire dalla v25, anziché utilizzare un bid_modifier moltiplicativo, puoi impostare offerte manuali basate su CPC (cpc_bid_micros) su entità di hotel specifiche (entity_bid.item_code) nelle campagne sulla rete di ricerca per i viaggi (campagne sulla rete di ricerca con campagne AI Max per la rete di ricerca abilitate e un feed di hotel collegato) utilizzando il EntityBid (CriterionType.VERTICAL_ADS_ITEM_BID) criterio su AdGroupCriterion. È richiesta l'offerta MANUAL_CPC. Per maggiori dettagli, consulta Offerta CPC manuale per entità.

Codice di esempio

Il seguente esempio di codice mostra come aggiungere un modificatore di offerta per dispositivi mobili a livello di gruppo di annunci:

Java

private void runExample(
    GoogleAdsClient googleAdsClient, long customerId, long adGroupId, double bidModifier) {

  // Creates an ad group bid modifier for mobile devices with the specified ad group ID and
  // bid modifier value.
  AdGroupBidModifier adGroupBidModifier =
      AdGroupBidModifier.newBuilder()
          .setAdGroup(ResourceNames.adGroup(customerId, adGroupId))
          .setBidModifier(bidModifier)
          .setDevice(DeviceInfo.newBuilder().setType(Device.MOBILE))
          .build();

  // Creates an ad group bid modifier operation for creating an ad group bid modifier.
  AdGroupBidModifierOperation adGroupBidModifierOperation =
      AdGroupBidModifierOperation.newBuilder().setCreate(adGroupBidModifier).build();

  // Issues a mutate request to add the ad group bid modifier.
  try (AdGroupBidModifierServiceClient adGroupBidModifierServiceClient =
      googleAdsClient.getLatestVersion().createAdGroupBidModifierServiceClient()) {
    MutateAdGroupBidModifiersResponse response =
        adGroupBidModifierServiceClient.mutateAdGroupBidModifiers(
            Long.toString(customerId), ImmutableList.of(adGroupBidModifierOperation));

    System.out.printf("Added %d ad group bid modifiers:%n", response.getResultsCount());
    for (MutateAdGroupBidModifierResult mutateAdGroupBidModifierResult :
        response.getResultsList()) {
      System.out.printf("\t%s%n", mutateAdGroupBidModifierResult.getResourceName());
    }
  }
}
AddAdGroupBidModifier.java
      

C#

public void Run(GoogleAdsClient client, long customerId, long adGroupId,
    double bidModifierValue)
{
    // Get the AdGroupBidModifierService.
    AdGroupBidModifierServiceClient adGroupBidModifierService =
        client.GetService(Services.V25.AdGroupBidModifierService);

    // Creates an ad group bid modifier for mobile devices with the specified ad group
    // ID and bid modifier value.
    AdGroupBidModifier adGroupBidModifier = new AdGroupBidModifier()
    {
        AdGroup = ResourceNames.AdGroup(customerId, adGroupId),
        BidModifier = bidModifierValue,
        Device = new DeviceInfo()
        {
            Type = Device.Mobile
        }
    };

    // Creates an ad group bid modifier operation for creating an ad group bid modifier.
    AdGroupBidModifierOperation adGroupBidModifierOperation =
        new AdGroupBidModifierOperation()
        {
            Create = adGroupBidModifier
        };

    // Send the operation in a mutate request.
    try
    {
        MutateAdGroupBidModifiersResponse response =
            adGroupBidModifierService.MutateAdGroupBidModifiers(customerId.ToString(),
                new AdGroupBidModifierOperation[] { adGroupBidModifierOperation });
        Console.WriteLine("Added {0} ad group bid modifiers:", response.Results.Count);
        foreach (MutateAdGroupBidModifierResult result in response.Results)
        {
            Console.WriteLine($"\t{result.ResourceName}");
        }
    }
    catch (GoogleAdsException e)
    {
        Console.WriteLine("Failure:");
        Console.WriteLine($"Message: {e.Message}");
        Console.WriteLine($"Failure: {e.Failure}");
        Console.WriteLine($"Request ID: {e.RequestId}");
        throw;
    }
}
AddAdGroupBidModifier.cs
      

PHP

    public static function runExample(
        GoogleAdsClient $googleAdsClient,
        int $customerId,
        int $adGroupId,
        float $bidModifierValue
    ) {
        // Creates an ad group bid modifier for mobile devices with the specified ad group ID and
        // bid modifier value.
        $adGroupBidModifier = new AdGroupBidModifier(
            [
            'ad_group' => ResourceNames::forAdGroup($customerId, $adGroupId),
            'bid_modifier' => $bidModifierValue,
            'device' => new DeviceInfo(['type' => Device::MOBILE])
            ]
        );

        // Creates an ad group bid modifier operation for creating an ad group bid modifier.
        $adGroupBidModifierOperation = new AdGroupBidModifierOperation();
        $adGroupBidModifierOperation->setCreate($adGroupBidModifier);

        // Issues a mutate request to add the ad group bid modifier.
        $adGroupBidModifierServiceClient = $googleAdsClient->getAdGroupBidModifierServiceClient();
        $response = $adGroupBidModifierServiceClient->mutateAdGroupBidModifiers(
            MutateAdGroupBidModifiersRequest::build($customerId, [$adGroupBidModifierOperation])
        );

        printf("Added %d ad group bid modifier:%s", $response->getResults()->count(), PHP_EOL);

        foreach ($response->getResults() as $addedAdGroupBidModifier) {
            /**
 * @var AdGroupBidModifier $addedAdGroupBidModifier
*/
            print $addedAdGroupBidModifier->getResourceName() . PHP_EOL;
        }
    }
AddAdGroupBidModifier.php
      

Python

def main(
    client: GoogleAdsClient,
    customer_id: str,
    ad_group_id: str,
    bid_modifier_value: float,
) -> None:
    ad_group_service: AdGroupServiceClient = client.get_service(
        "AdGroupService"
    )
    ad_group_bm_service: AdGroupBidModifierServiceClient = client.get_service(
        "AdGroupBidModifierService"
    )

    # Create ad group bid modifier for mobile devices with the specified ad
    # group ID and bid modifier value.
    ad_group_bid_modifier_operation: AdGroupBidModifierOperation = (
        client.get_type("AdGroupBidModifierOperation")
    )
    ad_group_bid_modifier: AdGroupBidModifier = (
        ad_group_bid_modifier_operation.create
    )

    # Set the ad group.
    ad_group_bid_modifier.ad_group = ad_group_service.ad_group_path(
        customer_id, ad_group_id
    )

    # Set the bid modifier.
    ad_group_bid_modifier.bid_modifier = bid_modifier_value

    # Sets the device.
    device_enum: DeviceEnum = client.enums.DeviceEnum
    ad_group_bid_modifier.device.type_ = device_enum.MOBILE

    # Add the ad group bid modifier.
    ad_group_bm_response: MutateAdGroupBidModifiersResponse = (
        ad_group_bm_service.mutate_ad_group_bid_modifiers(
            customer_id=customer_id,
            operations=[ad_group_bid_modifier_operation],
        )
    )
add_ad_group_bid_modifier.py
      

Ruby

def add_ad_group_bid_modifier(customer_id, ad_group_id, bid_modifier_value)
  # GoogleAdsClient will read a config file from
  # ENV['HOME']/google_ads_config.rb when called without parameters
  client = Google::Ads::GoogleAds::GoogleAdsClient.new

  # Creates an ad group bid modifier for mobile devices with the specified
  # ad group ID and bid modifier value.
  ad_group_bid_modifier = client.resource.ad_group_bid_modifier do |mod|
    # Sets the ad group.
    mod.ad_group = client.path.ad_group(customer_id, ad_group_id)

    # Sets the Bid Modifier.
    mod.bid_modifier = bid_modifier_value

    # Sets the Device.
    mod.device = client.resource.device_info do |device|
      device.type = :MOBILE
    end
  end

  # Create the operation.
  operation = client.operation.create_resource.ad_group_bid_modifier(ad_group_bid_modifier)

  # Add the ad group ad.
  response = client.service.ad_group_bid_modifier.mutate_ad_group_bid_modifiers(
    customer_id: customer_id,
    operations: [operation]
  )

  puts "Added #{response.results.size} ad group bid modifiers:"
  response.results.each do |added_ad_group_bid_modifier|
    puts "\t#{added_ad_group_bid_modifier.resource_name}"
  end
end
add_ad_group_bid_modifier.rb
      

Perl

sub add_ad_group_bid_modifier {
  my ($api_client, $customer_id, $ad_group_id, $bid_modifier_value) = @_;

  # Create an ad group bid modifier for mobile devices with the specified ad group ID and
  # bid modifier value.
  my $ad_group_bid_modifier =
    Google::Ads::GoogleAds::V25::Resources::AdGroupBidModifier->new({
      adGroup => Google::Ads::GoogleAds::V25::Utils::ResourceNames::ad_group(
        $customer_id, $ad_group_id
      ),
      bidModifier => $bid_modifier_value,
      device      => Google::Ads::GoogleAds::V25::Common::DeviceInfo->new({
          type => MOBILE
        })});

  # Create an ad group bid modifier operation.
  my $ad_group_bid_modifier_operation =
    Google::Ads::GoogleAds::V25::Services::AdGroupBidModifierService::AdGroupBidModifierOperation
    ->new({
      create => $ad_group_bid_modifier
    });

  # Add the ad group bid modifier.
  my $ad_group_bid_modifiers_response =
    $api_client->AdGroupBidModifierService()->mutate({
      customerId => $customer_id,
      operations => [$ad_group_bid_modifier_operation]});

  printf "Created ad group bid modifier '%s'.\n",
    $ad_group_bid_modifiers_response->{results}[0]{resourceName};

  return 1;
}
add_ad_group_bid_modifier.pl
      

curl

Nota: anche se qui non viene fornito un esempio di codice REST diretto per questo passaggio, puoi ottenerlo utilizzando una richiesta REST manuale.

Consulta la documentazione dell'interfaccia REST dell'API Google Ads e le pagine di riferimento specifiche per il metodo. Dovrai creare il payload JSON in base alle definizioni del proto.

Risorse chiave:

• Utilizzo di REST
• Struttura dell'interfaccia REST
• Mappature dei campi JSON
• Consulta il Riferimento API REST per il servizio e il metodo specifici.