Bidding Strategy Assignment

Standard bidding strategies

To use a standard bidding strategy with your campaign, set the campaign as follows:

This example demonstrates how to set a standard MAXIMIZE_CONVERSION_VALUE bidding strategy when creating a new campaign:

Java

// Creates the campaign.
Campaign campaign =
    Campaign.newBuilder()
        .setName("Interplanetary Cruise #" + System.currentTimeMillis())
        // Configures settings related to shopping campaigns including advertising channel type,
        // advertising sub-type and shopping setting.
        .setAdvertisingChannelType(AdvertisingChannelType.SHOPPING)
        .setAdvertisingChannelSubType(AdvertisingChannelSubType.SHOPPING_SMART_ADS)
        .setShoppingSetting(shoppingSetting)
        // Recommendation: Sets the campaign to PAUSED when creating it to prevent
        // the ads from immediately serving. Set to ENABLED once you've added
        // targeting and the ads are ready to serve.
        .setStatus(CampaignStatus.PAUSED)
        // Bidding strategy must be set directly on the campaign.
        // Setting a portfolio bidding strategy by resourceName is not supported.
        // Maximize conversion value is the only strategy supported for Smart Shopping
        // campaigns.
        // An optional ROAS (Return on Advertising Spend) can be set for
        // MaximizeConversionValue.
        // The ROAS value must be specified as a ratio in the API. It is calculated by dividing
        // "total value" by "total spend".
        // For more information on maximize conversion value, see the support article:
        // http://support.google.com/google-ads/answer/7684216)
        .setMaximizeConversionValue(
            MaximizeConversionValue.newBuilder().setTargetRoas(3.5).build())
        // Sets the budget.
        .setCampaignBudget(budgetResourceName)
        .build();

C#

// Create the standard shopping campaign.
Campaign campaign = new Campaign()
{
    Name = "Interplanetary Cruise #" + ExampleUtilities.GetRandomString(),

    // Configures settings related to shopping campaigns including advertising channel
    // type, sub-type and shopping setting.
    AdvertisingChannelType = AdvertisingChannelType.Shopping,
    AdvertisingChannelSubType = AdvertisingChannelSubType.ShoppingSmartAds,

    ShoppingSetting = shoppingSetting,

    // Recommendation: Set the campaign to PAUSED when creating it to prevent
    // the ads from immediately serving. Set to ENABLED once you've added
    // targeting and the ads are ready to serve
    Status = CampaignStatus.Paused,

    // Bidding strategy must be set directly on the campaign.
    // Setting a portfolio bidding strategy by resourceName is not supported.
    // Maximize conversion value is the only strategy supported for Smart Shopping
    // campaigns.
    // An optional ROAS (Return on Advertising Spend) can be set for
    // MaximizeConversionValue.
    // The ROAS value must be specified as a ratio in the API. It is calculated by
    // dividingW "total value" by "total spend".
    // For more information on maximize conversion value, see the support article:
    // http://support.google.com/google-ads/answer/7684216)
    MaximizeConversionValue = new MaximizeConversionValue()
    {
        TargetRoas = 3.5
    },

    // Sets the budget.
    CampaignBudget = budgetResourceName
};

PHP

// Creates the campaign.
$campaign = new Campaign([
    'name' => 'Interplanetary Cruise Campaign #' . uniqid(),
    // Configures settings related to shopping campaigns including
    // advertising channel type, advertising sub-type and shopping setting.
    'advertising_channel_type' => AdvertisingChannelType::SHOPPING,
    'advertising_channel_sub_type' => AdvertisingChannelSubType::SHOPPING_SMART_ADS,
    'shopping_setting' => $shoppingSettings,
    // Recommendation: Set the campaign to PAUSED when creating it to prevent
    // the ads from immediately serving. Set to ENABLED once you've added
    // targeting and the ads are ready to serve.
    'status' => CampaignStatus::PAUSED,
    // Bidding strategy must be set directly on the campaign.
    // Setting a portfolio bidding strategy by resource name is not supported.
    // Maximize conversion value is the only strategy supported for Smart Shopping
    // campaigns.
    // An optional ROAS (Return on Advertising Spend) can be set for
    // MaximizeConversionValue.
    // The ROAS value must be specified as a ratio in the API. It is calculated by dividing
    // "total value" by "total spend".
    // For more information on maximize conversion value, see the support article:
    // http://support.google.com/google-ads/answer/7684216.
    'maximize_conversion_value' => new MaximizeConversionValue(['target_roas' => 3.5]),
    // Sets the budget.
    'campaign_budget' => $budgetResourceName
]);

Ruby

def add_smart_shopping_campaign(
    client, customer_id, budget_name, merchant_center_id)

  operation = client.operation.create_resource.campaign do |campaign|
    campaign.name = "Interplanetary Cruise Campaign ##{(Time.new.to_f * 1000).to_i}"

    # Configures settings related to shopping campaigns including
    # advertising channel type, advertising sub-type and shopping setting.
    campaign.advertising_channel_type = :SHOPPING
    campaign.advertising_channel_sub_type = :SHOPPING_SMART_ADS
    campaign.shopping_setting = client.resource.shopping_setting do |shopping_setting|
      shopping_setting.merchant_id = merchant_center_id
      # Sets the sales country of products to include in the campaign.
      # Only products from Merchant Center targeting this country will appear in the
      # campaign.
      shopping_setting.sales_country = "US"
    end

    # Recommendation: Set the campaign to PAUSED when creating it to prevent
    # the ads from immediately serving. Set to ENABLED once you've added
    # targeting and the ads are ready to serve.
    campaign.status = :PAUSED

    # Bidding strategy must be set directly on the campaign.
    # Setting a portfolio bidding strategy by resource name is not supported.
    # Maximize conversion value is the only strategy supported for Smart Shopping
    # campaigns.
    # An optional ROAS (Return on Advertising Spend) can be set for
    # MaximizeConversionValue.
    # The ROAS value must be specified as a ratio in the API. It is calculated by dividing
    # "total value" by "total spend".
    # For more information on maximize conversion value, see the support article:
    # http://support.google.com/google-ads/answer/7684216.
    campaign.maximize_conversion_value = client.resource.maximize_conversion_value do |m|
      m.target_roas = 3.5
    end

    campaign.campaign_budget = budget_name
  end

  response = client.service.campaign.mutate_campaigns(
    customer_id: customer_id,
    operations: [operation],
  )

  campaign_name = response.results.first.resource_name

  puts "Added a Smart Shopping Campaign with resource name #{campaign_name}."

  campaign_name
end

Perl

my $campaign = Google::Ads::GoogleAds::V5::Resources::Campaign->new({
    name => "Interplanetary Cruise Campaign #" . uniqid(),
    # Configure settings related to shopping campaigns including advertising
    # channel type, advertising channel sub-type and shopping setting.
    advertisingChannelType    => SHOPPING,
    advertisingChannelSubType => SHOPPING_SMART_ADS,
    shoppingSetting =>
      Google::Ads::GoogleAds::V5::Resources::ShoppingSetting->new({
        merchantId => $merchant_center_account_id,
        # Set the sales country of products to include in the campaign.
        # Only products from Merchant Center targeting this country will
        # appear in the campaign.
        salesCountry => "US"
      }
      ),
    # Recommendation: Set the campaign to PAUSED when creating it to prevent
    # the ads from immediately serving. Set to ENABLED once you've added
    # targeting and the ads are ready to serve.
    status => Google::Ads::GoogleAds::V5::Enums::CampaignStatusEnum::PAUSED,
    # Bidding strategy must be set directly on the campaign.
    # Setting a portfolio bidding strategy by resource name is not supported.
    # Maximize conversion value is the only strategy supported for smart shopping
    # campaigns. An optional ROAS (Return on Advertising Spend) can be set for
    # MaximizeConversionValue. The ROAS value must be specified as a ratio in the
    # API. It is calculated by dividing "total value" by "total spend".
    # For more information on maximize conversion value, see the support article:
    # http://support.google.com/google-ads/answer/7684216.
    maximizeConversionValue =>
      Google::Ads::GoogleAds::V5::Common::MaximizeConversionValue->new(
      {targetRoas => 3.5}
      ),
    # Set the budget.
    campaignBudget => $budget_resource_name
  });

Portfolio bidding strategies

To use a portfolio bidding strategy with your campaign, you have two options:

  1. Use an existing BiddingStrategy.
  2. Use MutateBiddingStrategies to create a new one with the fields name and scheme set. As an example, for an ENHANCED_CPC bidding strategy, set the field enhanced_cpc with a new object typed as EnhancedCpc.

Once you've chosen a BiddingStrategy, configure your campaign to use it by setting the campaign's bidding_strategy field to its resource_name.

The following example demonstrates how to create a new portfolio ENHANCED_CPC bidding strategy for a new campaign.

Java

private String createBiddingStrategy(GoogleAdsClient googleAdsClient, long customerId) {
  try (BiddingStrategyServiceClient biddingStrategyServiceClient =
      googleAdsClient.getLatestVersion().createBiddingStrategyServiceClient()) {
    // Creates a portfolio bidding strategy.
    TargetSpend targetSpend = TargetSpend.newBuilder().setCpcBidCeilingMicros(2_000_000L).build();
    BiddingStrategy portfolioBiddingStrategy =
        BiddingStrategy.newBuilder()
            .setName("Maximize Clicks #" + System.currentTimeMillis())
            .setTargetSpend(targetSpend)
            .build();
    // Constructs an operation that will create a portfolio bidding strategy.
    BiddingStrategyOperation operation =
        BiddingStrategyOperation.newBuilder().setCreate(portfolioBiddingStrategy).build();
    // Sends the operation in a mutate request.
    MutateBiddingStrategiesResponse response =
        biddingStrategyServiceClient.mutateBiddingStrategies(
            Long.toString(customerId), Lists.newArrayList(operation));

    MutateBiddingStrategyResult mutateBiddingStrategyResult = response.getResults(0);
    // Prints the resource name of the created object.
    System.out.printf(
        "Created portfolio bidding strategy with resource name: '%s'.%n",
        mutateBiddingStrategyResult.getResourceName());

    return mutateBiddingStrategyResult.getResourceName();
  }
}

C#

private string CreatePortfolioBiddingStrategy(GoogleAdsClient client,
    long customerId, string name, long bidCeiling)
{
    // Get the BiddingStrategyService.
    BiddingStrategyServiceClient biddingStrategyService = client.GetService(
        Services.V5.BiddingStrategyService);

    // Create a portfolio bidding strategy.
    BiddingStrategy biddingStrategy = new BiddingStrategy()
    {
        Name = name,

        TargetSpend = new TargetSpend()
        {
            CpcBidCeilingMicros = bidCeiling,
        }
    };

    // Create operation.
    BiddingStrategyOperation biddingOperation = new BiddingStrategyOperation()
    {
        Create = biddingStrategy
    };

    // Create the portfolio bidding strategy.
    MutateBiddingStrategiesResponse biddingResponse =
        biddingStrategyService.MutateBiddingStrategies(
            customerId.ToString(), new BiddingStrategyOperation[] { biddingOperation });

    return biddingResponse.Results[0].ResourceName;
}

PHP

private static function createBiddingStrategy(GoogleAdsClient $googleAdsClient, int $customerId)
{
    // Creates a portfolio bidding strategy.
    $portfolioBiddingStrategy = new BiddingStrategy([
        'name' => 'Maximize Clicks #' . uniqid(),
        'target_spend' => new TargetSpend([
            'cpc_bid_ceiling_micros' => 2000000
        ])
    ]);

    // Constructs an operation that will create a portfolio bidding strategy.
    $biddingStrategyOperation = new BiddingStrategyOperation();
    $biddingStrategyOperation->setCreate($portfolioBiddingStrategy);

    // Issues a mutate request to create the bidding strategy.
    $biddingStrategyServiceClient = $googleAdsClient->getBiddingStrategyServiceClient();
    $response = $biddingStrategyServiceClient->mutateBiddingStrategies(
        $customerId,
        [$biddingStrategyOperation]
    );
    /** @var BiddingStrategy $addedBiddingStrategy */
    $addedBiddingStrategy = $response->getResults()[0];

    // Prints out the resource name of the created bidding strategy.
    printf(
        "Created portfolio bidding strategy with resource name: '%s'.%s",
        $addedBiddingStrategy->getResourceName(),
        PHP_EOL
    );

    return $addedBiddingStrategy->getResourceName();
}

Python

# Create a portfolio bidding strategy.
bidding_strategy_operation = client.get_type(
    "BiddingStrategyOperation", version="v5"
)
bidding_strategy = bidding_strategy_operation.create
bidding_strategy.name = "Enhanced CPC %s" % uuid.uuid4()
target_spend = bidding_strategy.target_spend
target_spend.cpc_bid_ceiling_micros = 2000000

# Add portfolio bidding strategy.
try:
    bidding_strategy_response = bidding_strategy_service.mutate_bidding_strategies(
        customer_id, [bidding_strategy_operation]
    )
except google.ads.google_ads.errors.GoogleAdsException as ex:
    print(
        'Request with ID "%s" failed with status "%s" and includes the '
        "following errors:" % (ex.request_id, ex.error.code().name)
    )
    for error in ex.failure.errors:
        print('\tError with message "%s".' % error.message)
        if error.location:
            for field_path_element in error.location.field_path_elements:
                print("\t\tOn field: %s" % field_path_element.field_name)
    sys.exit(1)

bidding_strategy_id = bidding_strategy_response.results[0].resource_name

print('Portfolio bidding strategy "%s" was created.' % bidding_strategy_id)

Ruby

# Create a portfolio bidding strategy.
bidding_strategy = client.resource.bidding_strategy do |bs|
  bs.name = "Enhanced CPC ##{(Time.new.to_f * 1000).to_i}"
  bs.enhanced_cpc = client.resource.enhanced_cpc
end

operation = client.operation.create_resource.bidding_strategy(bidding_strategy)

response = client.service.bidding_strategy.mutate_bidding_strategies(
  customer_id: customer_id,
  operations: [operation],
)
bidding_id = response.results.first.resource_name

puts "Portfolio bidding strategy #{bidding_id} was created"

Perl

sub create_bidding_strategy {
  my ($api_client, $customer_id) = @_;

  # Create a portfolio bidding strategy.
  my $portfolio_bidding_strategy =
    Google::Ads::GoogleAds::V5::Resources::BiddingStrategy->new({
      name        => "Maximize Clicks #" . uniqid(),
      targetSpend => Google::Ads::GoogleAds::V5::Common::TargetSpend->new({
          cpcBidCeilingMicros => 2000000
        }
      ),
    });

  # Create a bidding strategy operation.
  my $bidding_strategy_operation =
    Google::Ads::GoogleAds::V5::Services::BiddingStrategyService::BiddingStrategyOperation
    ->new({
      create => $portfolio_bidding_strategy
    });

  # Add the bidding strategy.
  my $bidding_strategy_response =
    $api_client->BiddingStrategyService()->mutate({
      customerId => $customer_id,
      operations => [$bidding_strategy_operation]});

  my $bidding_strategy_resource_name =
    $bidding_strategy_response->{results}[0]{resourceName};

  printf "Created portfolio bidding strategy with resource name: '%s'.\n",
    $bidding_strategy_resource_name;

  return $bidding_strategy_resource_name;
}

Java

Campaign campaign =
    Campaign.newBuilder()
        .setName("Interplanetary Cruise #" + System.currentTimeMillis())
        .setStatus(CampaignStatus.PAUSED)
        .setCampaignBudget(campaignBudgetResourceName)
        .setBiddingStrategy(biddingStrategyResourceName)
        .setAdvertisingChannelType(AdvertisingChannelType.SEARCH)
        .setNetworkSettings(networkSettings)
        .build();

C#

// Create the campaign.
Campaign campaign = new Campaign()
{
    Name = name,
    AdvertisingChannelType = AdvertisingChannelType.Search,

    // Recommendation: Set the campaign to PAUSED when creating it to prevent
    // the ads from immediately serving. Set to ENABLED once you've added
    // targeting and the ads are ready to serve.
    Status = CampaignStatus.Paused,

    // Set the campaign budget.
    CampaignBudget = campaignBudgetResourceName,

    // Set bidding strategy (required).
    BiddingStrategy = biddingStrategyResourceName,

    // Set the campaign network options.
    NetworkSettings = new NetworkSettings()
    {
        TargetGoogleSearch = true,
        TargetSearchNetwork = true,
        TargetContentNetwork = true,
        TargetPartnerSearchNetwork = false
    }
};

PHP

// Creates a Search campaign.
$campaign = new Campaign([
    'name' => 'Interplanetary Cruise #' . uniqid(),
    'advertising_channel_type' => AdvertisingChannelType::SEARCH,
    // Recommendation: Set the campaign to PAUSED when creating it to prevent
    // the ads from immediately serving. Set to ENABLED once you've added
    // targeting and the ads are ready to serve.
    'status' => CampaignStatus::PAUSED,
    // Configures the campaign network options.
    'network_settings' => new NetworkSettings([
        'target_google_search' => true,
        'target_search_network' => true,
        'target_content_network' => true,
    ]),
    // Sets the bidding strategy and budget.
    'bidding_strategy' => $biddingStrategyResourceName,
    'campaign_budget' => $campaignBudgetResourceName
]);

Python

# Create campaign.
campaign_operation = client.get_type("CampaignOperation", version="v5")
campaign = campaign_operation.create
campaign.name = "Interplanetary Cruise %s" % uuid.uuid4()
campaign.advertising_channel_type = client.get_type(
    "AdvertisingChannelTypeEnum"
).SEARCH

# Recommendation: Set the campaign to PAUSED when creating it to prevent the
# ads from immediately serving. Set to ENABLED once you've added targeting
# and the ads are ready to serve.
campaign.status = client.get_type("CampaignStatusEnum", version="v5").PAUSED

# Set the bidding strategy and budget.
campaign.bidding_strategy = bidding_strategy_id
campaign.manual_cpc.enhanced_cpc_enabled = True
campaign.campaign_budget = campaign_budget_id

# Set the campaign network options.
campaign.network_settings.target_google_search = True
campaign.network_settings.target_search_network = True
campaign.network_settings.target_content_network = False
campaign.network_settings.target_partner_search_network = False

Ruby

# Create campaigns.
campaigns = 2.times.map do |i|
  client.resource.campaign do |c|
    c.name = "Interplanetary Cruise ##{(Time.new.to_f * 1000).to_i + i}"
    c.status = :PAUSED
    c.bidding_strategy = bidding_id
    c.campaign_budget = budget_id
    c.advertising_channel_type = :SEARCH
    c.network_settings = client.resource.network_settings do |ns|
      ns.target_google_search = true
      ns.target_search_network = true
      ns.target_content_network = false
      ns.target_partner_search_network = false
    end
  end
end

Perl

# Create a search campaign.
my $campaign = Google::Ads::GoogleAds::V5::Resources::Campaign->new({
    name                   => "Interplanetary Cruise #" . uniqid(),
    advertisingChannelType => SEARCH,
    # Recommendation: Set the campaign to PAUSED when creating it to stop
    # the ads from immediately serving. Set to ENABLED once you've added
    # targeting and the ads are ready to serve.
    status => PAUSED,
    # Configures the campaign network options.
    networkSettings =>
      Google::Ads::GoogleAds::V5::Resources::NetworkSettings->new({
        targetGoogleSearch   => "true",
        targetSearchNetwork  => "true",
        targetContentNetwork => "true"
      }
      ),
    # Set the bidding strategy and budget.
    biddingStrategy => $bidding_strategy_resource_name,
    campaignBudget  => $campaign_budget_resource_name
  });

Bidding strategy transitions

To update a campaign's bidding strategy, in a CampaignOperation.update, set the fields of the Campaign as previously described.