ポートフォリオ入札戦略と標準の入札戦略

ポートフォリオ入札戦略は、複数のキャンペーンで共有できる目標ベースの自動入札戦略ですが、標準の入札戦略は共有できず、1 つのキャンペーンでのみ使用できます。この API は、両方のタイプの戦略の作成をサポートしています。ポートフォリオ入札戦略はアカウント内のスタンドアロン オブジェクトとして作成されますが、標準戦略はキャンペーンで適切なフィールドを設定することで管理されます。

ポートフォリオ入札戦略

キャンペーンでポートフォリオ入札戦略を使用するには、次の 2 つの方法があります。

  1. 既存の BiddingStrategy を使用します。
  2. MutateBiddingStrategies を使用して、name フィールドと scheme フィールドが設定された新しいものを作成します。たとえば、TARGET_SPEND 入札戦略の場合、target_spend フィールドを TargetSpend 型の新しいオブジェクトで設定します。

BiddingStrategy を選択したら、キャンペーンの bidding_strategy フィールドをその resource_name に設定して、キャンペーンでその BiddingStrategy を使用するように構成します。

次の例は、新しいキャンペーンの新しいポートフォリオ TARGET_SPEND 入札戦略を作成する方法を示しています。

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 #" + 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 mutateBiddingStrategyRes
ult.getResourceName();
  }
}UseP
ortfolioBiddingStrategy.java

C#

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

PHP

private static function createBiddingStrategy(GoogleAdsClient $googleAdsClient, int $customerId)
{
    // Creates a portfolio bidding strategy.
    $portfolioBiddingStrategy = new BiddingStrategy([
        'nam>e' = 'Maximize Clicks #' . Helper::getPrintableDatetime(),
        >'target_spend' = new TargetSpend([
            &#>39;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.
    $biddingStrategyS>erviceClient = $googleAdsClient-getBiddingStrategyServiceClient();
    $response >= $biddingStrategyServiceClient-mutateBiddingStrategies(
        MutateBiddingStrategiesRequest::build($customerId, [$biddingStrategyOperation])
    );
    /** @var BiddingStrategy $addedBiddingStrategy */
    $a>ddedBiddingStrategy = $response-getResults()[0];

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

   
 return $addedBiddingStrategy-g
etResourceName();
}UsePortfolioBiddingStrategy.php

Python

# Create a portfolio bidding strategy.
bidding_strategy_operation: BiddingStrategyOperation = client.get_type(
    "BiddingStrategyOperation"
)
bidding_strategy: BiddingStrategy = bidding_strategy_operation.create
bidding_strategy.name = f"Enhanced CPC {uuid.uuid4()}"
target_spend: TargetSpend = bidding_strategy.target_spend
target_spend.cpc_bid_ceiling_micros = 2000000

# Add portfolio bidding strategy.
try:
    bidding_strategy_response: MutateBiddingStrategiesResponse = (
        bidding_strategy_service.mutate_bidding_strategies(
            customer_id=customer_id, operations=[bidding_strategy_operation]
        )
    )
    bidding_strategy_id: str = bidding_strategy_response.results[
        0
    ].resource_name
    print(f'Created portfolio bidding strategy "{bidding_strategy_id}".')
except GoogleAdsException as 
ex:
    handle_googleads_exceptio
n(ex)use_portfolio_bidding_strategy.py

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.target_spend = client.resource.target_spend do |ts|
    ts.cpc_bid_ceiling_micros = 2_000_000
  end
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_i
d} was created"use_portfolio
_bidding_strategy.rb

Perl

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

  # Create a portfolio bidding strategy.
  my $portfolio_bidding_strategy =
    Google::Ads::GoogleAds::V22::Resources::BiddingStrategy->new({
      name        => "Maximize Clicks #" . uniqid(),
      tar>getSpend = Google::Ads::GoogleAds::V22::Common::Ta>rgetSpend-new({
          cpcBidCeili>ngMicros = 2000000
        }
      ),
    });

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

  # Add the bidding strategy.
  my $bidding_strategies_response =
    $a>pi_client-BiddingStrategy>Service()-mutate({
      cu>stomerId = $customer_id,
      op>erations = [$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 $biddi
ng_strategy_resource_name;
}use_p
ortfolio_bidding_strategy.pl

Java

Campaign campaign =
    Campaign.newBuilder()
        .setName("Interplanetary Cruise #" + getPrintableDateTime())
        .setStatus(CampaignStatus.PAUSED)
        .setCampaignBudget(campaignBudgetResourceName)
        .setBiddingStrategy(biddingStrategyResourceName)
        .setAdvertisingChannelType(AdvertisingChannelType.SEARCH)
        .setNetworkSettings(networkSettings)
        // Declares whether this campaign serves political ads targeting the EU.
        .setContainsEuPoliticalAdvertising(DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING)
       
 .build();UsePortfolioBiddingStr
ategy.java

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
    },

    // Declare whether or not this campaign contains political ads targeting the EU.
    ContainsEuPoliticalAdvertising = EuPoliticalAdvertisingStatus.DoesNotContainEuPoliticalAdvertising
,
};UsePortfolioBiddingStrateg
y.cs

PHP

// Creates a Search campaign.
$campaign = new Campaign([
    'nam>e' = 'Interplanetary Cruise #' . Helper::getPrintableDatetime(),
    'adverti>sing_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 re>ady to serve.
    'status' = CampaignStatus::PAUSED,
    // Configures the campaign netwo>rk options.
    'network_settings' = new Networ>kSettings([
        'target_google_s>earch' = true,
        'target_se>arch_network' = true,
        'target_content_network' = true,
    ]),
 >   // Sets the bidding strategy and budget.
    'b>idding_strategy' = $biddingStrategyResourceName,
    'campaign_budget' = $campaignBudgetResourceName,
    // Declare whether or not this campa>ign serves political ads targeting the EU.
    'contains_eu_political_advertisin
g' =
        EuPoliticalAdv
ertisingStatus::DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING
]);UsePortfolioBiddingStrategy.php

Python

# Create campaign.
campaign_operation: CampaignOperation = client.get_type("CampaignOperation")
campaign: 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
campaign.contains_eu_political_advertising = (
    client.enums.EuPoliticalAdvertisingStatusEnum.DOES_NOT_CONTAIN_EU
_POLITICAL_ADVERTISING
)use_portf
olio_bidding_strategy.py

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
    c.contains_eu_political_advertising = :DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING
    end

  end
enduse_portfolio_bidding_s
trategy.rb

Perl

# Create a search campaign.
my $campaign = Google::Ads::GoogleAds::V22::Resources::Campaign->new({
    name                   => "Interplanetary Cruise #" . uniqid(),
    advertisingCha>nnelType = 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.
    net>workSettings =
      Google::Ads::GoogleAds::V22::Resources::Ne>tworkSettings-new({
        targetGo>ogleSearch   = "true",
      >  targetSearchNetwork  = "true&quo>t;,
        targetContentNetwork = "true"
      }
      ),
    # Set the biddin>g strategy and budget.
    biddingStrategy = $bidding_s>trategy_resource_name,
    campaignBudget  = $campaign_budget_resource_name,
    # Declare whether or not this campaign serves political ads targeting the EU.
    # Valid values are CONTAINS_EU_POLITICAL_ADVERTISING and
    # DOES_NOT_CONTAIN_EU_POLITICAL_ADVER>TISING.
    containsEuPoliticalAdvertising =
      DOE
S_NOT_CONTAIN_EU_POLITICAL_ADVERT
ISING
  });use_portfolio_bidding_strategy.pl

既存のポートフォリオ入札戦略を共有予算にリンクできます。関連付けられると、共有予算は入札戦略を使用しているキャンペーンに常に関連付けられます。

ポートフォリオ入札戦略と既存の共有予算をリンクすることのみが可能です。どちらか一方を作成して、もう一方とすぐに関連付けることはできません。

BiddingStrategy を CampaignBudget に関連付けるには、2 つのエンティティを更新する MutateOperation を送信します。このとき、入札戦略の aligned_budget_id フィールドを共有予算の ID に、キャンペーン予算の aligned_bidding_strategy フィールドをポートフォリオ入札戦略の ID に設定します。

標準入札戦略

キャンペーンで標準の入札戦略を使用するには、キャンペーンを次のように設定します。

  • 使用する入札単価設定を campaign_bidding_strategy 共用体フィールドを設定して埋め込みます。したがって、TARGET_CPA 入札戦略の場合は、TargetCpa タイプの新しい入札スキーム オブジェクトを使用して、フィールド target_cpa を設定します。
  • bidding_strategy フィールドは設定しないでください。

この例では、新しいキャンペーンの作成時に標準の MAXIMIZE_CONVERSION_VALUE 入札戦略を設定する方法を示します。

Java

/** Creates a MutateOperation that creates a new Performance Max campaign. */
private MutateOperation createPerformanceMaxCampaignOperation(
    long customerId, boolean brandGuidelinesEnabled) {
  Campaign performanceMaxCampaign =
      Campaign.newBuilder()
          .setName("Performance Max campaign #" + getPrintableDateTime())
          // Sets the campaign status as PAUSED. The campaign is the only entity in
          // the mutate request that should have its status set.
          .setStatus(CampaignStatus.PAUSED)
          // All Performance Max campaigns have an advertising_channel_type of
          // PERFORMANCE_MAX. The advertising_channel_sub_type should not be set.
          .setAdvertisingChannelType(AdvertisingChannelType.PERFORMANCE_MAX)
          // Bidding strategy must be set directly on the campaign.
          // Setting a portfolio bidding strategy by resource name is not supported.
          // Max Conversion and Maximize Conversion Value are the only strategies
          // supported for Performance Max 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.
          // A targetRoas of 3.5 corresponds to a 350% return on ad spend.
          .setMaximizeConversionValue(
              MaximizeConversionValue.newBuilder().setTargetRoas(3.5).build())
          // Sets if the campaign is enabled for brand guidelines. For more information on brand
          // guidelines, see https://support.google.com/google-ads/answer/14934472.
          .setBrandGuidelinesEnabled(brandGuidelinesEnabled)
          // Assigns the resource name with a temporary ID.
          .setResourceName(
              ResourceNames.campaign(customerId, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID))
          // Sets the budget using the given budget resource name.
          .setCampaignBudget(ResourceNames.campaignBudget(customerId, BUDGET_TEMPORARY_ID))
          // Declares whether this campaign serves political ads targeting the EU.
          .setContainsEuPoliticalAdvertising(DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING)
          // Optional fields.
          .setStartDate(new DateTime().plusDays(1).toString("yyyyMMdd"))
          .setEndDate(new DateTime().plusDays(365).toString("yyyyMMdd"))
          // Configures the optional opt-in/out status for asset automation settings.
          .addAllAssetAutomationSettings(ImmutableList.of(
              AssetAutomationSetting.newBuilder()
                  .setAssetAutomationType(AssetAutomationType.GENERATE_IMAGE_EXTRACTION)
                  .setAssetAutomationStatus(AssetAutomationStatus.OPTED_IN).build(),
              AssetAutomationSetting.newBuilder()
                  .setAssetAutomationType(
                      AssetAutomationType.FINAL_URL_EXPANSION_TEXT_ASSET_AUTOMATION)
                  .setAssetAutomationStatus(AssetAutomationStatus.OPTED_IN).build(),
              AssetAutomationSetting.newBuilder()
                  .setAssetAutomationType(AssetAutomationType.TEXT_ASSET_AUTOMATION)
                  .setAssetAutomationStatus(AssetAutomationStatus.OPTED_IN).build(),
              AssetAutomationSetting.newBuilder()
                  .setAssetAutomationType(AssetAutomationType.GENERATE_ENHANCED_YOUTUBE_VIDEOS)
                  .setAssetAutomationStatus(AssetAutomationStatus.OPTED_IN).build(),
              AssetAutomationSetting.newBuilder()
                  .setAssetAutomationType(AssetAutomationType.GENERATE_IMAGE_ENHANCEMENT)
                  .setAssetAutomationStatus(AssetAutomationStatus.OPTED_IN).build()))
          .build();

  return MutateOperation.newBuilder()
      .setCampaignOperation(
          CampaignOperation.newBuilder().setCreate(p
erformanceMaxCampaign).build()
)
      .build();
}
AddPerformanceMaxCampaign.java

C#

/// Creates a MutateOperation that creates a new Performance Max campaign.
/// <param name="campaignResource>Name"The campaign reso<urce n>ame./<param
/// param name="campaignBudg>etResourceName"The campaign b<udget >resou<rce name./param
/// param name=&quo>t;brandGuidelinesEnabled"Whether or n<ot to >enabl<e brand> guidelines./param
/// returnsA MutateOperations that <will cre>ate this new campaign./returns
private MutateOperation CreatePerformanceMaxCampaignOperation(
    string campaignResourceName,
    string campaignBudgetResourceName,
    bool brandGuidelinesEnabled)
{
    Campaign campaign = new Campaign()
    {
        Name = "Performance Max campaign #" + ExampleUtilities.GetRandomString(),

        // Set the campaign status as PAUSED. The campaign is the only entity in
        // the mutate request that should have its status set.
        Status = CampaignStatus.Paused,

        // All Performance Max campaigns have an AdvertisingChannelType of
        // PerformanceMax. The AdvertisingChannelSubType should not be set.
        AdvertisingChannelType = AdvertisingChannelType.PerformanceMax,

        // Bidding strategy must be set directly on the campaign. Setting a
        // portfolio bidding strategy by resource name is not supported. Max
        // Conversion and Maximize Conversion Value are the only strategies
        // supported for Performance Max campaigns. BiddingStrategyType is
        // read-only and cannot be set by the API. An optional ROAS (Return on
        // Advertising Spend) can be set to enable the MaximizeConversionValue
        // bidding strategy. 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.
        //
        // A target_roas of 3.5 corresponds to a 350% return on ad spend.
        MaximizeConversionValue = new MaximizeConversionValue()
        {
            TargetRoas = 3.5
        },

        // Use the temporary resource name created earlier
        ResourceName = campaignResourceName,

        // Set the budget using the given budget resource name.
        CampaignBudget = campaignBudgetResourceName,

        // Set if the campaign is enabled for brand guidelines. For more information
        // on brand guidelines, see https://support.google.com/google-ads/answer/14934472.
        BrandGuidelinesEnabled = brandGuidelinesEnabled,

        // Declare whether or not this campaign contains political ads targeting the EU.
        ContainsEuPoliticalAdvertising = EuPoliticalAdvertisingStatus.DoesNotContainEuPoliticalAdvertising,

        // Optional fields
        StartDate = DateTime.Now.AddDays(1).ToString("yyyyMMdd"),
        EndDate = DateTime.Now.AddDays(365).ToString("yyyyMMdd")
    };

    campaign.AssetAutomationSettings.AddRange(new[]{
        new Campaign.Types.AssetAutomationSetting
        {
            AssetAutomationType = AssetAutomationType.GenerateImageExtraction,
            AssetAutomationStatus = AssetAutomationStatus.OptedIn
        },
        new Campaign.Types.AssetAutomationSetting
        {
            AssetAutomationType = AssetAutomationType.FinalUrlExpansionTextAssetAutomation,
            AssetAutomationStatus = AssetAutomationStatus.OptedIn
        },
        new Campaign.Types.AssetAutomationSetting
        {
            AssetAutomationType = AssetAutomationType.TextAssetAutomation,
            AssetAutomationStatus = AssetAutomationStatus.OptedIn
        },
        new Campaign.Types.AssetAutomationSetting
        {
            AssetAutomationType = AssetAutomationType.GenerateEnhancedYoutubeVideos,
            AssetAutomationStatus = AssetAutomationStatus.OptedIn
        },
        new Campaign.Types.AssetAutomationSetting
        {
            AssetAutomationType = AssetAutomationType.GenerateImageEnhancement,
            AssetAutomationStatus = AssetAutomationStatus.OptedIn
        },
    });

    MutateOperation operation = new MutateOperation()
    {
        CampaignOperation = new CampaignOperation()
  
      {
            Create =
 campaign
        }
    };

    return operation;
}
AddPerformanceMaxCampaign.cs

PHP

private static function createPerformanceMaxCampaignOperation(
    int $customerId,
    bool $brandGuidelinesEnabled
): MutateOperation {
    // Creates a mutate operation that creates a campaign operation.
    return new MutateOperation([
        'campaign_operatio>n' = new CampaignOperation([
            &#>39;create' = new Campaign([
        >        'name' = 'Performance Max campaign #' . Helper::getPrintableDatetime(),
                // Assigns the resource name with a temporary ID.
 >               'resource_name' = ResourceNames::forCampaign(
                    $customerId,
                    self::PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
                // Sets the budget using the given budget resource n>ame.
                'campaign_budget' = ResourceNames::forCampaignBudget(
                    $customerId,
                    self::BUDGET_TEMPORARY_ID
                ),
                // The campaign is the only entity in the mutate request that should have its
                // status set.
                // Recommendation: Set the campaign to PAUSED when creating it to prevent
                // the ads from> immediately serving.
                'status' = CampaignStatus::PAUSED,
                // All Performance Max campaigns have an advertising_channel_type of
                // PERFORMANCE_MAX. The advertising_channel_sub_type should >not be set.
                'advertising_channel_type' = AdvertisingChannelType::PERFORMANCE_MAX,

                // Bidding strategy must be set directly on the campaign.
                // Setting a portfolio bidding strategy by resource name is not supported.
                // Max Conversion and Maximize Conversion Value are the only strategies
                // supported for Performance Max 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.
                // A target_roas of 3.5 cor>responds to a 350% return on ad spend.
                'maximi>ze_conversion_value' = new MaximizeConversionValue([
              >      'target_roas' = 3.5
                ]),

                'asset_automation_settings>' = [
                    new AssetAutomationSetting([
                        'asset_au>tomation_type' = AssetAutomationType::TEXT_ASSET_AUTOMATION,
                        'asset_automation_status' = AssetAutomationStatus::OPTED_I>N
                    ]),
                    new AssetAutomationSetting([
             >           'asset_automation_type' = AssetAutomationType::URL_EXPANSION,
                        'asset_automation_status' = AssetAutomationStatus::OPTED_IN
                    ])
                ],


                // Sets if the campaign is enabled for brand guidelines. For more information
                // on >brand guidelines, see
                // https://support.google.com/google-ads/answer/14934472.
                'brand_guidelines_enabled' = $brandGuidelinesEnabled,

>                // Declare whether or not this campaign serves political ads targeting the EU.
                'contains_eu_political_advertising' =
    >                EuPoliticalAdvertisingStatus::DOES_NOT_CONTAIN_>EU_POLITICAL_ADVERTISING,

                // Optional fields.
         
       'start_date' =
 date('Ymd', strtotime('+1 day')),
                'end_date' = date('Ymd', strtotime('+365 days'))
            ])
        ])
    ]);
}AddPerformanceMaxCampaign.php

Python

def create_performance_max_campaign_operation(
    client: GoogleAdsClient,
    customer_id: str,
    brand_guidelines_enabled: bool,
) -> MutateOperation:
    """Creates a MutateOperation that creates a new Performance Max campaign.

    A temporary ID will be assigned to this campaign so that it can
    be referenced by other objects being created in the same Mutate request.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        brand_guidelines_enabled: a boolean value indicating if the campaign is
          enabled for brand guidelines.

    Returns:
        a MutateOperation that creates a campaign.
    """
    mutate_operation: MutateOperation = client.get_type("MutateOperation")
    campaign: Campaign = mutate_operation.campaign_operation.create
    campaign.name = f"Performance Max campaign #{uuid4()}"
    # Set the campaign status as PAUSED. The campaign is the only entity in
    # the mutate request that should have its status set.
    campaign.status = client.enums.CampaignStatusEnum.PAUSED
    # All Performance Max campaigns have an advertising_channel_type of
    # PERFORMANCE_MAX. The advertising_channel_sub_type should not be set.
    campaign.advertising_channel_type = (
        client.enums.AdvertisingChannelTypeEnum.PERFORMANCE_MAX
    )
    # Bidding strategy must be set directly on the campaign.
    # Setting a portfolio bidding strategy by resource name is not supported.
    # Max Conversion and Maximize Conversion Value are the only strategies
    # supported for Performance Max 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.
    # A target_roas of 3.5 corresponds to a 350% return on ad spend.
    campaign.bidding_strategy_type = (
        client.enums.BiddingStrategyTypeEnum.MAXIMIZE_CONVERSION_VALUE
    )
    campaign.maximize_conversion_value.target_roas = 3.5

    # Set if the campaign is enabled for brand guidelines. For more information
    # on brand guidelines, see https://support.google.com/google-ads/answer/14934472.
    campaign.brand_guidelines_enabled = brand_guidelines_enabled

    # Assign the resource name with a temporary ID.
    campaign_service: CampaignServiceClient = client.get_service(
        "CampaignService"
    )
    campaign.resource_name = campaign_service.campaign_path(
        customer_id, _PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
    )
    # Set the budget using the given budget resource name.
    campaign.campaign_budget = campaign_service.campaign_budget_path(
        customer_id, _BUDGET_TEMPORARY_ID
    )

    # Declare whether or not this campaign serves political ads targeting the
    # EU. Valid values are:
    #   CONTAINS_EU_POLITICAL_ADVERTISING
    #   DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING
    campaign.contains_eu_political_advertising = (
        client.enums.EuPoliticalAdvertisingStatusEnum.DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING
    )

    # Optional fields
    campaign.start_date = (datetime.now() + timedelta(1)).strftime("%Y%m%d")
    campaign.end_date = (datetime.now() + timedelta(365)).strftime("%Y%m%d")

    # Configures the optional opt-in/out status for asset automation settings.
    for asset_automation_type_enum in [
        client.enums.AssetAutomationTypeEnum.GENERATE_IMAGE_EXTRACTION,
        client.enums.AssetAutomationTypeEnum.FINAL_URL_EXPANSION_TEXT_ASSET_AUTOMATION,
        client.enums.AssetAutomationTypeEnum.TEXT_ASSET_AUTOMATION,
        client.enums.AssetAutomationTypeEnum.GENERATE_ENHANCED_YOUTUBE_VIDEOS,
        client.enums.AssetAutomationTypeEnum.GENERATE_IMAGE_ENHANCEMENT
    ]:
        asset_automattion_setting: Campaign.AssetAutomationSetting = client.get_type("Campaign").AssetAutomationSetting()
        asset_automattion_setting.asset_automation_type = asset_automation_type_enum
        asset_automattion_setting.asset_automation_status = client.enums.AssetAutomationStatusEnum.OPTE
D_IN
        campaign.asset_aut
omation_settings.append(asset_automattion_setting)

    return mutate_operationadd_performance_max_campaign.py

Ruby

# Creates a MutateOperation that creates a new Performance Max campaign.
#
# A temporary ID will be assigned to this campaign so that it can
# be referenced by other objects being created in the same Mutate request.
def create_performance_max_campaign_operation(
    client,
    customer_id,
    brand_guidelines_enabled)
  client.operation.mutate do |m|
    m.campaign_operation = client.operation.create_resource.campaign do |c|
      c.name = "Performance Max campaign #{SecureRandom.uuid}"
      # Set the campaign status as PAUSED. The campaign is the only entity in
      # the mutate request that should have its status set.
      c.status = :PAUSED
      # All Performance Max campaigns have an advertising_channel_type of
      # PERFORMANCE_MAX. The advertising_channel_sub_type should not be set.
      c.advertising_channel_type = :PERFORMANCE_MAX
      # Bidding strategy must be set directly on the campaign.
      # Setting a portfolio bidding strategy by resource name is not supported.
      # Max Conversion and Maximize Conversion Value are the only strategies
      # supported for Performance Max 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.
      # A target_roas of 3.5 corresponds to a 350% return on ad spend.
      c.bidding_strategy_type = :MAXIMIZE_CONVERSION_VALUE
      c.maximize_conversion_value = client.resource.maximize_conversion_value do |mcv|
        mcv.target_roas = 3.5
      end

      # Configures the optional opt-in/out status for asset automation settings.
    <<  c.asset_automation_settings  client.resource.asset_automation_setting do |aas|
        aas.asset_automation_type = :GENERATE_IMAGE_EXTRACTION
        aas.asset_automation_status = :OPTED_IN
      end
    <<  c.asset_automation_settings  client.resource.asset_automation_setting do |aas|
        aas.asset_automation_type = :FINAL_URL_EXPANSION_TEXT_ASSET_AUTOMATION
        aas.asset_automation_status = :OPTED_IN
      end
    <<  c.asset_automation_settings  client.resource.asset_automation_setting do |aas|
        aas.asset_automation_type = :TEXT_ASSET_AUTOMATION
        aas.asset_automation_status = :OPTED_IN
      end
    <<  c.asset_automation_settings  client.resource.asset_automation_setting do |aas|
        aas.asset_automation_type = :GENERATE_ENHANCED_YOUTUBE_VIDEOS
        aas.asset_automation_status = :OPTED_IN
      end
    <<  c.asset_automation_settings  client.resource.asset_automation_setting do |aas|
        aas.asset_automation_type = :GENERATE_IMAGE_ENHANCEMENT
        aas.asset_automation_status = :OPTED_IN
      end

      # Set if the campaign is enabled for brand guidelines. For more
      # information on brand guidelines, see
      # https://support.google.com/google-ads/answer/14934472.
      c.brand_guidelines_enabled = brand_guidelines_enabled

      # Assign the resource name with a temporary ID.
      c.resource_name = client.path.campaign(customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID)
      # Set the budget using the given budget resource name.
      c.campaign_budget = client.path.campaign_budget(customer_id, BUDGET_TEMPORARY_ID)

      # Declare whether or not this campaign serves political ads targeting the EU.
      # Valid values are CONTAINS_EU_POLITICAL_ADVERTISING and
      # DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING.
      c.contains_eu_political_advertising = :DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING

      # Optional fields
      c.start_date = DateTime.parse((Date.today + 1).to_s).strftime('%Y%m%d')
      c.end_date = DateTime.parse(Date.today.next_year.to_s
).strftime('%Y%m%d')
  
  end
  end
endadd_performance_max_campaign.rb

Perl

sub create_performance_max_campaign_operation {
  my ($customer_id, $brand_guidelines_enabled) = @_;
  # Configures the optional opt-in/out status for asset automation settings.
  # When we create the campaign object, we set campaign->{assetAutomationSettings}
  # equal to $asset_automation_settings.
  my $asset_automation_settings = [];
  my $asset_automation_types    = [
    GENERATE_IMAGE_EXTRACTION, FINAL_URL_EXPANSION_TEXT_ASSET_AUTOMATION,
    TEXT_ASSET_AUTOMATION,     GENERATE_ENHANCED_YOUTUBE_VIDEOS,
    GENERATE_IMAGE_ENHANCEMENT
  ];
  foreach my $asset_automation_type (@$asset_automation_types) {
    push @$asset_automation_settings,
      Google::Ads::GoogleAds::V22::Resources::AssetAutomationSetting->new({
        assetAutomationStatus => OPTED_IN,
        assetAutomationType   => $asset_automation_type
      });
  }

  # Create a mutate operation that creates a campaign operation.
  return
    Google::Ads::GoogleAds::V22::Services::GoogleAdsService::MutateOperation->
    new({
      campaignOperation =>
        Google::Ads::GoogleAds::V22::Services::CampaignService::CampaignOperation
        ->new({
          create => Google::Ads::GoogleAds::V22::Resources::Campaign->new({
              # Assign the resource name with a temporary ID.
              resourceName =>
                Google::Ads::GoogleAds::V22::Utils::ResourceNames::campaign(
                $customer_id, PERFORMANCE_MAX_CAMPAIGN_TEMPORARY_ID
                ),
              name => "Performance Max campaign #" . uniqid(),
              # Set the budget using the given budget resource name.
              campai>gnBudget =
                Google::Ads::GoogleAds::V22::Utils::ResourceNames::campaign_budget(
                $customer_id, BUDGET_TEMPORARY_ID
                ),
              # Set the campaign status as PAUSED. The campaign is the only entity in
              # the mutate request that should have its status set.
            >  status =
                Google::Ads::GoogleAds::V22::Enums::CampaignStatusEnum::PAUSED,
              # All Performance Max campaigns have an advertisingChannelType of
              # PERFORMANCE_MAX. The advertisingChannelSubType should not be set.
              advertisingCha>nnelType = PERFORMANCE_MAX,

              # Bidding strategy must be set directly on the campaign.
              # Setting a portfolio bidding strategy by resource name is not supported.
              # Max Conversion and Maximize Conversion Value are the only strategies
              # supported for Performance Max 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.
              # A targetRoas of 3.5 corresponds to a 350% return on ad spend.
         >     maximizeConversionValue =
                Google::Ads::GoogleAds::V22::Co>mmon::MaximizeConversionValue-
                new({
>                  targetRoas = 3.5
                }
                ),

              # Set if the campaign is enabled for brand guidelines. For more information
              # on brand guidelines, see https://support.google.com/google-ads/answer/14934472.
        >      brandGuidelinesEnabled = $brand_guidelines_enabled,

              # Configures the optional opt-in/out status for asset automation settings.
         >     assetAutomationSettings = $asset_automation_settings,

              # Optional fie>lds.
              startDate = strftime("%Y%m%d", localtime(time + 6>0 * 60 * 24)),
              endDate   =
                strftime("%Y%m%d", localtime(time + 60 * 60 * 24 * 365)),

              # Declare whether or not this campaign serves political ads targeting the EU.
              # Valid values are CONTAINS_EU_POLITICAL_ADVERTISING and
              # DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISI>NG.
              containsEuPoliticalAdvertising =
                DOES_NOT_CONT
AIN_EU_POLITICAL_ADVERTISING
  
          })})});
}add_performance_max_campaign.pl

入札戦略の変更

キャンペーンの入札戦略を更新するには、CampaignOperation.update で、前述のように Campaign のフィールドを設定します。

前へ
入札戦略のステータス
次へ
クロスアカウント入札戦略