Portfolio and Standard Bidding Strategies

Portfolio bidding strategies are automated, goal-driven bidding strategies that can be shared among multiple campaigns, whereas standard bidding strategies are not shared and can only be used by a single campaign. The API supports creating both types of strategies. Portfolio bidding strategies are created as standalone objects in an account, whereas standard strategies are managed by setting appropriate fields on a campaign.

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.

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 #" + getPrintableDateTime())
            .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();
  }
}
UsePortfolioBiddingStrategy.java
      

private string CreatePortfolioBiddingStrategy(GoogleAdsClient client,
    long customerId, string name, long bidCeiling)
{
    // Get the BiddingStrategyService.
    BiddingStrategyServiceClient biddingStrategyService = client.GetService(
        Services.V8.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;
}
UsePortfolioBiddingStrategy.cs
      

private static function createBiddingStrategy(GoogleAdsClient $googleAdsClient, int $customerId)
{
    // Creates a portfolio bidding strategy.
    $portfolioBiddingStrategy = new BiddingStrategy([
        'name' => 'Maximize Clicks #' . Helper::getPrintableDatetime(),
        '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();
}
UsePortfolioBiddingStrategy.php
      

# Create a portfolio bidding strategy.
bidding_strategy_operation = client.get_type("BiddingStrategyOperation")
bidding_strategy = bidding_strategy_operation.create
bidding_strategy.name = f"Enhanced CPC {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=customer_id, operations=[bidding_strategy_operation]
        )
    )
    bidding_strategy_id = bidding_strategy_response.results[0].resource_name
    print(f'Created portfolio bidding strategy "{bidding_strategy_id}".')
except GoogleAdsException as ex:
    _handle_googleads_exception(ex)
use_portfolio_bidding_strategy.py
      

# 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.target_spend = Google::Ads::GoogleAds::V8::Common::TargetSpend.new
  bs.target_spend.cpc_bid_ceiling_micros = 2_000_000
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"
use_portfolio_bidding_strategy.rb
      

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

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

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

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

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

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

  return $bidding_strategy_resource_name;
}
use_portfolio_bidding_strategy.pl
      

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

// 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
    }
};
UsePortfolioBiddingStrategy.cs
      

// Creates a Search campaign.
$campaign = new Campaign([
    'name' => 'Interplanetary Cruise #' . Helper::getPrintableDatetime(),
    '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
]);
UsePortfolioBiddingStrategy.php
      

# Create campaign.
campaign_operation = client.get_type("CampaignOperation")
campaign = campaign_operation.create
campaign.name = f"Interplanetary Cruise {uuid.uuid4()}"
campaign.advertising_channel_type = (
    client.enums.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.enums.CampaignStatusEnum.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
use_portfolio_bidding_strategy.py
      

# 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
use_portfolio_bidding_strategy.rb
      

# Create a search campaign.
my $campaign = Google::Ads::GoogleAds::V8::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::V8::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
  });
use_portfolio_bidding_strategy.pl
      

Standard bidding strategies

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

• Embed the bidding scheme to be used by setting the campaign_bidding_strategy union field. So for a TARGET_CPA bidding strategy, set the field target_cpa with a new bidding scheme object of type TargetCpa).
• Do not set the bidding_strategy field.

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

// Creates the campaign.
Campaign campaign =
    Campaign.newBuilder()
        .setName("Interplanetary Cruise #" + getPrintableDateTime())
        // 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();
AddShoppingSmartAd.java
      

// 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
};
AddShoppingSmartAd.cs
      

// Creates the campaign.
$campaign = new Campaign([
    'name' => 'Interplanetary Cruise Campaign #' . Helper::getPrintableDatetime(),
    // 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
]);
AddShoppingSmartAd.php
      

# Create a campaign operation and configure the smart shopping campaign.
campaign_operation = client.get_type("CampaignOperation")
campaign = campaign_operation.create
campaign.name = f"Interplanetary Cruise Campaign #{uuid4()}"
campaign.campaign_budget = budget_resource_name
# Configure settings related to shopping campaigns including advertising
# channel type, advertising channel sub-type and shopping setting.
campaign.advertising_channel_type = (
    client.enums.AdvertisingChannelTypeEnum.SHOPPING
)
campaign.advertising_channel_sub_type = (
    client.enums.AdvertisingChannelSubTypeEnum.SHOPPING_SMART_ADS
)
campaign.shopping_setting.merchant_id = 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.
campaign.shopping_setting.sales_country = "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.
campaign.status = client.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 maximize_conversion_value. 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.target_roas = 3.5
add_shopping_smart_ad.py
      

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 = Google::Ads::GoogleAds::V8::Common::MaximizeConversionValue.new
    campaign.maximize_conversion_value.target_roas = 3.5

    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
add_shopping_smart_ad.rb
      

my $campaign = Google::Ads::GoogleAds::V8::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::V8::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::V8::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::V8::Common::MaximizeConversionValue->new(
      {targetRoas => 3.5}
      ),
    # Set the budget.
    campaignBudget => $budget_resource_name
  });
add_shopping_smart_ad.pl
      

Bidding strategy transitions

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