Shopping Campaign Samples

The code samples below provide examples for managing Shopping campaigns using the AdWords API. Client Library.

Build a product partition tree for an ad group

#!/usr/bin/perl -w
#
# Copyright 2017, Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This example creates a ProductPartition tree.

use strict;
use lib "../../../lib";
use utf8;

use Data::Uniqid qw(uniqid);

use Google::Ads::AdWords::Client;
use Google::Ads::AdWords::Logging;
use Google::Ads::AdWords::v201809::AdGroupCriterionOperation;
use Google::Ads::AdWords::v201809::BiddableAdGroupCriterion;
use Google::Ads::AdWords::v201809::BiddingStrategyConfiguration;
use Google::Ads::AdWords::v201809::CpcBid;
use Google::Ads::AdWords::v201809::Criterion;
use Google::Ads::AdWords::v201809::Money;
use Google::Ads::AdWords::v201809::NegativeAdGroupCriterion;
use Google::Ads::AdWords::v201809::ProductBiddingCategory;
use Google::Ads::AdWords::v201809::ProductCanonicalCondition;
use Google::Ads::AdWords::v201809::ProductBrand;
use Google::Ads::AdWords::v201809::ProductPartition;

use Cwd qw(abs_path);

# Replace with valid values of your account.
my $ad_group_id = "INSERT_AD_GROUP_ID_HERE";

# Example main subroutine.
sub add_product_partition_tree {
  my ($client, $ad_group_id) = @_;

  my $operations = [];

  # The next temporary criterion ID to be used.
  #
  # When creating our tree we need to specify the parent-child relationships
  # between nodes. However, until a criterion has been created on the server
  # we do not have a criterionId with which to refer to it.
  #
  # Instead we can specify temporary IDs that are specific to a single mutate
  # request. Once the criteria have been created they are assigned an ID as
  # normal and the temporary ID will no longer refer to it.
  #
  # A valid temporary ID is any negative integer.
  my $next_id = -1;

  # The most trivial partition tree has only a unit node as the root:
  #   create_unit($operations, $ad_group_id, null, null, 100000);
  my $root = create_subdivision($operations, $next_id--, $ad_group_id);

  create_unit(
    $operations,
    $ad_group_id,
    $root,
    Google::Ads::AdWords::v201809::ProductCanonicalCondition->new(
      {condition => "NEW"}
    ),
    200000
  );

  create_unit(
    $operations,
    $ad_group_id,
    $root,
    Google::Ads::AdWords::v201809::ProductCanonicalCondition->new(
      {condition => "USED"}
    ),
    100000
  );

  my $other_condition =
    create_subdivision($operations, $next_id--, $ad_group_id, $root,
    Google::Ads::AdWords::v201809::ProductCanonicalCondition->new());

  create_unit($operations, $ad_group_id, $other_condition,
    Google::Ads::AdWords::v201809::ProductBrand->new({value => "CoolBrand"}),
    900000);

  create_unit($operations, $ad_group_id, $other_condition,
    Google::Ads::AdWords::v201809::ProductBrand->new({value => "CheapBrand"}),
    10000);

  my $other_brand =
    create_subdivision($operations, $next_id--, $ad_group_id, $other_condition,
    Google::Ads::AdWords::v201809::ProductBrand->new());

  # The value for the bidding category is a fixed ID for the 'Luggage & Bags'
  # category. You can retrieve IDs for categories from the ConstantDataService.
  # See the 'get_product_category_taxonomy' example for more details.
  create_unit(
    $operations,
    $ad_group_id,
    $other_brand,
    Google::Ads::AdWords::v201809::ProductBiddingCategory->new({
        type  => "BIDDING_CATEGORY_L1",
        value => -5914235892932915235
      }
    ),
    750000
  );

  create_unit(
    $operations,
    $ad_group_id,
    $other_brand,
    Google::Ads::AdWords::v201809::ProductBiddingCategory->new(
      {type => "BIDDING_CATEGORY_L1",}
    ),
    110000
  );

  my $result =
    $client->AdGroupCriterionService()->mutate({operations => $operations});

  my $children = {};
  my $root_node;
  # For each criterion, make an array containing each of its children.
  # We always create the parent before the child, so we can rely on that here.
  foreach my $ad_group_criterion (@{$result->get_value()}) {
    $children->{$ad_group_criterion->get_criterion()->get_id()} = [];

    my $parent_criterion_id =
      $ad_group_criterion->get_criterion()->get_parentCriterionId();
    if ($parent_criterion_id) {
      push $children->{$parent_criterion_id},
        $ad_group_criterion->get_criterion();
    } else {
      $root_node = $ad_group_criterion->get_criterion();
    }
  }

  # Show the tree
  display_tree($root_node, $children);

  return 1;
}

# Return a new subdivision product partition and add to the provided list
# an operation to create the partition. The parent and value fields
# should not be specified for the root node.
# operations: The list of operations to add to.
# temp_id: The temporary ID to use for the new partition.
# ad_group_id: The ID of the ad group for the new partition.
# parent: (Optional) The parent partition for the new partition.
# value: (Optional) The case value (product dimension) for the new partition.
sub create_subdivision {
  my ($operations, $temp_id, $ad_group_id, $parent, $value) = @_;
  my $division = Google::Ads::AdWords::v201809::ProductPartition->new({
      partitionType => "SUBDIVISION",
      id            => $temp_id
  });

  # The root node has neither a parent nor a value.
  if ($parent) {
    $division->set_parentCriterionId($parent->get_id());
    $division->set_caseValue($value);
  }

  my $criterion = Google::Ads::AdWords::v201809::BiddableAdGroupCriterion->new({
      adGroupId => $ad_group_id,
      criterion => $division
  });

  push $operations, create_add_operation($criterion);

  return $division;
}

# Return a new unit product partition and add to the provided list
# an operation to create the partition. The parent, value and bid_amount
# fields should not be specified for the root node.
# operations: The list of operations to add to.
# ad_group_id: The ID of the ad group for the new partition.
# parent: (Optional) The parent partition for the new partition.
# value: (Optional) The case value (product dimension) for the new partition.
# bid_amount: (Optional) The bid amount for the AdGroupCriterion.  If specified
#   then the AdGroupCriterion will be a BiddableAdGroupCriterion.
sub create_unit {
  my ($operations, $ad_group_id, $parent, $value, $bid_amount) = @_;
  my $unit = Google::Ads::AdWords::v201809::ProductPartition->new(
    {partitionType => "UNIT",});

  # The root node has neither a parent nor a value.
  if ($parent) {
    $unit->set_parentCriterionId($parent->get_id());
    $unit->set_caseValue($value);
  }

  my $criterion;
  if ($bid_amount && $bid_amount > 0) {
    my $biddingStrategyConfiguration =
      Google::Ads::AdWords::v201809::BiddingStrategyConfiguration->new({
        bids => [
          Google::Ads::AdWords::v201809::CpcBid->new({
              bid => Google::Ads::AdWords::v201809::Money->new(
                {microAmount => $bid_amount})})]});

    $criterion =
      Google::Ads::AdWords::v201809::BiddableAdGroupCriterion->new({
        biddingStrategyConfiguration => $biddingStrategyConfiguration
      });
  } else {
    $criterion = Google::Ads::AdWords::v201809::NegativeAdGroupCriterion->new();
  }

  $criterion->set_adGroupId($ad_group_id);
  $criterion->set_criterion($unit);

  push $operations, create_add_operation($criterion);

  return $unit;
}

# Return a new ADD operation for the specified ad group criterion.
# ad_group_criterion: The ad group criterion for the new operation.
sub create_add_operation {
  my ($ad_group_criterion) = @_;
  my $operation = Google::Ads::AdWords::v201809::AdGroupCriterionOperation->new(
    {
      operand  => $ad_group_criterion,
      operator => "ADD"
    });

  return $operation;
}

# Recursively display a node and each of its children.
# node: The node (Criterion) to display.
# children: Reference to a hash of each criterion ID to the array of its
#   child criteria.
# level: (Optional) The depth of node in the criteria tree.
sub display_tree {
  my ($node, $children, $level) = @_;

  # Recursively display a node and each of its children.
  $level = 0 unless $level;
  my $value = '';
  my $type  = '';

  my $node_dimension = $node->get_caseValue();
  if ($node_dimension) {
    $type = $node_dimension->get_ProductDimension__Type();
    if ($type eq 'ProductCanonicalCondition') {
      $value = $node_dimension->get_condition();
    } elsif ($type eq 'ProductBiddingCategory') {
      $value =
        $node_dimension->get_type() . "(" .
        ($node_dimension->get_value() or '') . ")";
    } elsif ($type eq 'ProductBrand') {
      $value = $node_dimension->get_value();
    } else {
      $value = $node_dimension;
    }
    $value = '' unless $value;
  }

  printf "%sid: %s, type: %s, value: %s\n", "  " x $level,
    $node->get_id(), $type, $value;
  foreach my $child_node (@{$children->{$node->get_id()}}) {
    display_tree($child_node, $children, $level + 1);
  }
}

# Don't run the example if the file is being included.
if (abs_path($0) ne abs_path(__FILE__)) {
  return 1;
}

# Log SOAP XML request, response and API errors.
Google::Ads::AdWords::Logging::enable_all_logging();

# Get AdWords Client, credentials will be read from ~/adwords.properties.
my $client = Google::Ads::AdWords::Client->new({version => "v201809"});

# By default examples are set to die on any server returned fault.
$client->set_die_on_faults(1);

# Call the example
add_product_partition_tree($client, $ad_group_id);
add_product_partition_tree.pl

Set a product scope for a campaign

#!/usr/bin/perl -w
#
# Copyright 2017, Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This example restricts the products that will be included in the campaign by
# setting a ProductScope.

use strict;
use lib "../../../lib";
use utf8;

use Data::Uniqid qw(uniqid);

use Google::Ads::AdWords::Client;
use Google::Ads::AdWords::Logging;
use Google::Ads::AdWords::v201809::CampaignCriterion;
use Google::Ads::AdWords::v201809::CampaignCriterionOperation;
use Google::Ads::AdWords::v201809::ProductBiddingCategory;
use Google::Ads::AdWords::v201809::ProductBrand;
use Google::Ads::AdWords::v201809::ProductCanonicalCondition;
use Google::Ads::AdWords::v201809::ProductCustomAttribute;
use Google::Ads::AdWords::v201809::ProductOfferId;
use Google::Ads::AdWords::v201809::ProductScope;
use Google::Ads::AdWords::v201809::ProductType;

use Cwd qw(abs_path);

# Replace with valid values of your account.
my $campaign_id = "INSERT_CAMPAIGN_ID_HERE";

# Example main subroutine.
sub add_product_scope {
  my $client      = shift;
  my $campaign_id = shift;

  my $product_scope = Google::Ads::AdWords::v201809::ProductScope->new({
      # This set of dimensions is for demonstration purposes only. It would be
      # extremely unlikely that you want to include so many dimensions in your
      # product scope.
      dimensions => [
        Google::Ads::AdWords::v201809::ProductBrand->new({value => "Nexus"}),
        Google::Ads::AdWords::v201809::ProductCanonicalCondition->new(
          {condition => "NEW"}
        ),
        Google::Ads::AdWords::v201809::ProductCustomAttribute->new({
            type  => "CUSTOM_ATTRIBUTE_0",
            value => "my attribute value"
          }
        ),
        Google::Ads::AdWords::v201809::ProductOfferId->new({value => "book1"}),
        Google::Ads::AdWords::v201809::ProductType->new({
            type  => "PRODUCT_TYPE_L1",
            value => "Media"
          }
        ),
        Google::Ads::AdWords::v201809::ProductType->new({
            type  => "PRODUCT_TYPE_L2",
            value => "Books"
          }
        ),
        # The value for the bidding category is a fixed ID for the
        # 'Luggage & Bags' category. You can retrieve IDs for categories from the
        # ConstantDataService. See the 'get_product_category_taxonomy' example for
        # more details.
        Google::Ads::AdWords::v201809::ProductBiddingCategory->new({
            type  => "BIDDING_CATEGORY_L1",
            value => -5914235892932915235
          })]});

  my $campaign_criterion =
    Google::Ads::AdWords::v201809::CampaignCriterion->new({
      campaignId => $campaign_id,
      criterion  => $product_scope
    });

  # Create operation.
  my $operation =
    Google::Ads::AdWords::v201809::CampaignCriterionOperation->new({
      operand  => $campaign_criterion,
      operator => "ADD"
    });

  # Make the mutate request.
  my $result =
    $client->CampaignCriterionService()->mutate({operations => [$operation]});

  # Display result.
  $campaign_criterion = $result->get_value()->[0];

  printf("Created a ProductScope criterion with ID '%s'.\n",
    $campaign_criterion->get_criterion()->get_id());

  return 1;
}

# Don't run the example if the file is being included.
if (abs_path($0) ne abs_path(__FILE__)) {
  return 1;
}

# Log SOAP XML request, response and API errors.
Google::Ads::AdWords::Logging::enable_all_logging();

# Get AdWords Client, credentials will be read from ~/adwords.properties.
my $client = Google::Ads::AdWords::Client->new({version => "v201809"});

# By default examples are set to die on any server returned fault.
$client->set_die_on_faults(1);

# Call the example
add_product_scope($client, $campaign_id);
add_product_scope.pl

Add a Shopping campaign

#!/usr/bin/perl -w
#
# Copyright 2017, Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This example adds a Shopping campaign.

use strict;
use lib "../../../lib";
use utf8;

use Data::Uniqid qw(uniqid);

use Google::Ads::AdWords::Client;
use Google::Ads::AdWords::Logging;
use Google::Ads::AdWords::v201809::AdGroup;
use Google::Ads::AdWords::v201809::AdGroupAd;
use Google::Ads::AdWords::v201809::AdGroupAdOperation;
use Google::Ads::AdWords::v201809::AdGroupCriterionOperation;
use Google::Ads::AdWords::v201809::AdGroupOperation;
use Google::Ads::AdWords::v201809::BiddableAdGroupCriterion;
use Google::Ads::AdWords::v201809::BiddingStrategyConfiguration;
use Google::Ads::AdWords::v201809::Budget;
use Google::Ads::AdWords::v201809::Campaign;
use Google::Ads::AdWords::v201809::CampaignOperation;
use Google::Ads::AdWords::v201809::CpcBid;
use Google::Ads::AdWords::v201809::ProductAd;
use Google::Ads::AdWords::v201809::ProductPartition;
use Google::Ads::AdWords::v201809::ShoppingSetting;

use Cwd qw(abs_path);

# Replace with valid values of your account.
my $budget_id   = "INSERT_BUDGET_ID_HERE";
my $merchant_id = "INSERT_MERCHANT_CENTER_ID_HERE";
# If set to true (1), a default partition will be created. If running the
# add_product_partition_tree.pl example right after this example,
# make sure this stays set to false (0).
my $create_default_partition = 0;

# Example main subroutine.
sub add_shopping_campaign {
  my ($client, $budget_id, $merchant_id, $create_default_partition) = @_;

  my $campaign = Google::Ads::AdWords::v201809::Campaign->new({
      name => "Shopping campaign #" . uniqid(),
      # The advertisingChannelType is what makes this a Shopping campaign
      advertisingChannelType => "SHOPPING",
      # 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",
      # Set budget (required)
      budget =>
        Google::Ads::AdWords::v201809::Budget->new({budgetId => $budget_id}),
      # Set bidding strategy (required)
      biddingStrategyConfiguration =>
        Google::Ads::AdWords::v201809::BiddingStrategyConfiguration->new(
        {biddingStrategyType => "MANUAL_CPC"}
        ),
      # Set shopping setting (required)
      settings => [
        # All Shopping campaigns need a ShoppingSetting
        Google::Ads::AdWords::v201809::ShoppingSetting->new({
            salesCountry     => "US",
            campaignPriority => 0,
            merchantId       => $merchant_id,
            # By setting enableLocal to true (1) below, you will enable Local
            # Inventory Ads in your campaign. Set this to false (0) if you want
            # to disable this feature in your campaign.
            enableLocal => 1
          })]});

  # Create operation
  my $operation = Google::Ads::AdWords::v201809::CampaignOperation->new({
    operand  => $campaign,
    operator => "ADD"
  });

  # Make the mutate request
  my $result = $client->CampaignService()->mutate({operations => [$operation]});

  # Display result
  $campaign = $result->get_value()->[0];
  printf "Campaign name '%s' and ID %d was added.\n",
    $campaign->get_name(),
    $campaign->get_id();

  # Create ad group
  my $ad_group = Google::Ads::AdWords::v201809::AdGroup->new({
      campaignId => $campaign->get_id(),
      name       => "Ad Group #" . uniqid()});

  # Create operation
  $operation = Google::Ads::AdWords::v201809::AdGroupOperation->new({
    operand  => $ad_group,
    operator => "ADD"
  });

  # Make the mutate request
  $result = $client->AdGroupService()->mutate({operations => [$operation]});

  # Display result
  $ad_group = $result->get_value()->[0];
  printf "Ad group with name '%s' and ID %d was added.\n",
    $ad_group->get_name(),
    $ad_group->get_id();

  # Create product ad
  my $product_ad = Google::Ads::AdWords::v201809::ProductAd->new();

  # Create ad group ad
  my $ad_group_ad = Google::Ads::AdWords::v201809::AdGroupAd->new({
    adGroupId => $ad_group->get_id(),
    ad        => $product_ad
  });

  # Create operation
  $operation = Google::Ads::AdWords::v201809::AdGroupAdOperation->new({
    operand  => $ad_group_ad,
    operator => "ADD"
  });

  # Make the mutate request
  $result = $client->AdGroupAdService()->mutate({operations => [$operation]});

  # Display result
  $ad_group_ad = $result->get_value()->[0];
  printf "Product ad with ID %d was added.\n", $ad_group_ad->get_ad()->get_id();

  if ($create_default_partition) {
    # Create an ad group criterion for 'All products'.
    my $product_partition =
      Google::Ads::AdWords::v201809::ProductPartition->new({
        partitionType => 'UNIT',
        # Make sure the caseValue is null and the parentCriterionId is null.
        caseValue         => undef,
        parentCriterionId => undef
      });

    my $ad_group_criterion =
      Google::Ads::AdWords::v201809::BiddableAdGroupCriterion->new({
        adGroupId => $ad_group->get_id(),
        criterion => $product_partition,
        biddingStrategyConfiguration =>
          Google::Ads::AdWords::v201809::BiddingStrategyConfiguration->new({
            bids => [
              Google::Ads::AdWords::v201809::CpcBid->new({
                  bid => Google::Ads::AdWords::v201809::Money->new(
                    {microAmount => 500000})}
              ),
            ]})});

    # Create operation.
    $operation = Google::Ads::AdWords::v201809::AdGroupCriterionOperation->new({
      operator => "ADD",
      operand  => $ad_group_criterion
    });

    # Make the mutate request
    $result =
      $client->AdGroupCriterionService()->mutate({operations => [$operation]});

    # Display result
    $ad_group_criterion = $result->get_value()->[0];
    printf "Ad group criterion with ID %d in ad group with ID %d was added.\n",
      $ad_group_criterion->get_criterion()->get_id(),
      $ad_group_criterion->get_adGroupId();
  }

  return 1;
}

# Don't run the example if the file is being included.
if (abs_path($0) ne abs_path(__FILE__)) {
  return 1;
}

# Log SOAP XML request, response and API errors.
Google::Ads::AdWords::Logging::enable_all_logging();

# Get AdWords Client, credentials will be read from ~/adwords.properties.
my $client = Google::Ads::AdWords::Client->new({version => "v201809"});

# By default examples are set to die on any server returned fault.
$client->set_die_on_faults(1);

# Call the example
add_shopping_campaign($client, $budget_id, $merchant_id,
  $create_default_partition);
add_shopping_campaign.pl

Add a Smart Shopping campaign

#!/usr/bin/perl -w
#
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This example adds a Smart Shopping campaign with an ad group, and ad group
# ad.

use strict;
use lib "../../../lib";
use utf8;

use Data::Uniqid qw(uniqid);

use Google::Ads::AdWords::Client;
use Google::Ads::AdWords::Logging;
use Google::Ads::AdWords::v201809::AdGroup;
use Google::Ads::AdWords::v201809::AdGroupAd;
use Google::Ads::AdWords::v201809::AdGroupAdOperation;
use Google::Ads::AdWords::v201809::AdGroupCriterionOperation;
use Google::Ads::AdWords::v201809::AdGroupOperation;
use Google::Ads::AdWords::v201809::BiddableAdGroupCriterion;
use Google::Ads::AdWords::v201809::Campaign;
use Google::Ads::AdWords::v201809::CampaignOperation;
use Google::Ads::AdWords::v201809::BiddingStrategyConfiguration;
use Google::Ads::AdWords::v201809::Budget;
use Google::Ads::AdWords::v201809::BudgetOperation;
use Google::Ads::AdWords::v201809::GoalOptimizedShoppingAd;
use Google::Ads::AdWords::v201809::Money;
use Google::Ads::AdWords::v201809::ProductPartition;
use Google::Ads::AdWords::v201809::ShoppingSetting;

use Cwd qw(abs_path);

# Replace with valid values of your account.
my $merchant_id = "INSERT_MERCHANT_CENTER_ID_HERE";

# If set to true, a default partition will be created.
# Set it to false if you plan to run the add_product_partition_tree.pl
# example right after this example.
my $should_create_default_partition = 1;

# Example main subroutine.
sub add_smart_shopping_ad {
    my ($client, $merchant_id, $should_create_default_partition) = @_;

    my $budget_id = _create_budget($client);

    my $campaign_id = _create_smart_campaign($client, $budget_id, $merchant_id);

    my $ad_group_id = _create_smart_shopping_ad_group($client, $campaign_id);

    _create_smart_shopping_ad($client, $ad_group_id);

    if (defined($should_create_default_partition)
        && $should_create_default_partition) {
        _create_default_partition($client, $ad_group_id);
    }

    return 1;
}

# Creates a non-shared budget for a Smart Shopping campaign. Smart Shopping
# campaigns support only non-shared budgets.
sub _create_budget() {
    my ($client) = @_;

    my $budget = Google::Ads::AdWords::v201809::Budget->new({
        name => sprintf("Interplanetary Cruise Budget #%s", uniqid()),
        # This budget equals 50.00 units of your account's currency, e.g.,
        # 50 USD if your currency is USD.
        amount =>
            Google::Ads::AdWords::v201809::Money->new({
                microAmount => 50000000
        }),
        deliveryMethod => "STANDARD",
        # Non-shared budgets are required for Smart Shopping campaigns.
        isExplicitlyShared => 0
    });

    my $budget_operation = Google::Ads::AdWords::v201809::BudgetOperation->new({
        operator => "ADD",
        operand  => $budget
    });

    # Add budget.
    my $added_budget =
        $client->BudgetService()->mutate({ operations => ($budget_operation) })
            ->get_value()->[0];

    printf(
        "Budget with name '%s' and ID %d was created.\n",
        $added_budget->get_name(),
        $added_budget->get_budgetId());

    return $added_budget->get_budgetId();
}

# Creates a Smart Shopping campaign.
sub _create_smart_campaign {
    my ($client, $budget_id, $merchant_id) = @_;

    # Create a campaign with required and optional settings.
    my $campaign = Google::Ads::AdWords::v201809::Campaign->new({
        name                         => "Smart Shopping campaign #" . uniqid(),
        # The advertisingChannelType is what makes this a Shopping campaign.
        advertisingChannelType       => "SHOPPING",
        # Sets the advertisingChannelSubType to SHOPPING_GOAL_OPTIMIZED_ADS to
        # make this a Smart Shopping campaign.
        advertisingChannelSubType    => "SHOPPING_GOAL_OPTIMIZED_ADS",
        # 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",
        # Set budget (required)
        budget                       =>
            Google::Ads::AdWords::v201809::Budget
                ->new({ budgetId => $budget_id }),
        # Set a bidding strategy. Only MAXIMIZE_CONVERSION_VALUE is supported.
        biddingStrategyConfiguration =>
            Google::Ads::AdWords::v201809::BiddingStrategyConfiguration->new(
                { biddingStrategyType => "MAXIMIZE_CONVERSION_VALUE" }
            ),
        # All Shopping campaigns need a ShoppingSetting.
        settings                     => [
            Google::Ads::AdWords::v201809::ShoppingSetting->new({
                salesCountry => "US",
                merchantId   => $merchant_id
            }) ] });

    my $operation = Google::Ads::AdWords::v201809::CampaignOperation->new({
        operand  => $campaign,
        operator => "ADD"
    });

    # Create the campaign on the server and print out some information.
    my $added_campaign = $client->CampaignService()
        ->mutate({ operations => [ $operation ] })
        ->get_value()->[0];
    printf(
        "Smart Shopping campaign with name '%s' and ID %d was added.\n",
        $added_campaign->get_name(),
        $added_campaign->get_id());

    return $added_campaign->get_id();
}

# Creates a Smart Shopping ad group by setting the ad group type to
# SHOPPING_GOAL_OPTIMIZED_ADS.
sub _create_smart_shopping_ad_group {
    my ($client, $campaign_id) = @_;

    # Create an ad group.
    my $ad_group = Google::Ads::AdWords::v201809::AdGroup->new({
        campaignId  => $campaign_id,
        name        => "Smart Shopping ad group #" . uniqid(),
        # Set the ad group type to SHOPPING_GOAL_OPTIMIZED_ADS.
        adGroupType => "SHOPPING_GOAL_OPTIMIZED_ADS"
    });

    # Create operation.
    my $operation = Google::Ads::AdWords::v201809::AdGroupOperation->new({
        operand  => $ad_group,
        operator => "ADD"
    });

    # Create the ad group on the server and print out some information.
    my $added_ad_group = $client->AdGroupService()
        ->mutate({ operations => [ $operation ] })
        ->get_value()->[0];

    printf(
        "Smart Shopping ad group with name '%s' and ID %d was added.\n",
        $added_ad_group->get_name(),
        $added_ad_group->get_id()
    );
    return $added_ad_group->get_id();
}

# Creates a Smart Shopping ad.
sub _create_smart_shopping_ad {
    my ($client, $ad_group_id) = @_;

    # Create a Smart Shopping ad (Goal-optimized Shopping ad).
    my $smart_shopping_ad
        = Google::Ads::AdWords::v201809::GoalOptimizedShoppingAd->new({ });

    # Create ad group ad.
    my $ad_group_ad = Google::Ads::AdWords::v201809::AdGroupAd->new({
        adGroupId => $ad_group_id,
        ad        => $smart_shopping_ad
    });

    # Create an ad group ad operation and add it to the operations list.
    my $operation = Google::Ads::AdWords::v201809::AdGroupAdOperation->new({
        operand  => $ad_group_ad,
        operator => "ADD"
    });

    # Create the ad group ad on the server and print out some information.
    my $added_ad_group_ad =
        $client->AdGroupAdService()->mutate({ operations => [ $operation ] })
            ->get_value()->[0];
    printf(
        "Smart Shopping ad with ID %d was added.\n",
        $added_ad_group_ad->get_ad()->get_id()
    );
}

# Creates a default product partition as an ad group criterion.
sub _create_default_partition {
    my ($client, $ad_group_id) = @_;

    # Creates an ad group criterion for 'All products'.
    my $product_partition = Google::Ads::AdWords::v201809::ProductPartition
        ->new({ partitionType => "UNIT" });

    # Creates a biddable ad group criterion.
    my $criterion =
        Google::Ads::AdWords::v201809::BiddableAdGroupCriterion->new({
            adGroupId => $ad_group_id,
            criterion => $product_partition
        });

    # Creates an ad group criterion operation.
    my $operation = Google::Ads::AdWords::v201809::AdGroupCriterionOperation
        ->new({
        operand  => $criterion,
        operator => "ADD"
    });

    my $added_ad_group_criterion = $client->AdGroupCriterionService()
        ->mutate({ operations => [ $operation ] })
        ->get_value()->[0];
    printf(
        "Ad group criterion with ID %d in ad group with ID %d"
            . " was added.\n",
        $added_ad_group_criterion->get_criterion()->get_id(),
        $added_ad_group_criterion->get_adGroupId()
    );
}

# Log SOAP XML request, response and API errors.
Google::Ads::AdWords::Logging::enable_all_logging();

# Get AdWords Client, credentials will be read from ~/adwords.properties.
my $client = Google::Ads::AdWords::Client->new({ version => "v201809" });

# By default examples are set to die on any server returned fault.
$client->set_die_on_faults(1);

# Call the example
add_smart_shopping_ad($client, $merchant_id, $should_create_default_partition);
add_smart_shopping_ad.pl

Get the set of product bidding categories

#!/usr/bin/perl -w
#
# Copyright 2017, Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This example fetches the set of valid ProductBiddingCategories.

use strict;
use lib "../../../lib";
use utf8;

use Google::Ads::AdWords::Client;
use Google::Ads::AdWords::Logging;
use Google::Ads::AdWords::v201809::Selector;
use Google::Ads::AdWords::v201809::Predicate;

use Cwd qw(abs_path);

# Example main subroutine.
sub get_product_category_taxonomy {
  my $client = shift;

  # Create selector.
  my $selector = Google::Ads::AdWords::v201809::Selector->new({
      fields     => ["DimensionValue", "ParentDimensionValue", "DisplayValue"],
      predicates => [
        Google::Ads::AdWords::v201809::Predicate->new({
            field    => "Country",
            operator => "IN",
            values   => ["US"]})]});

  my $results =
    $client->ConstantDataService()
    ->getProductBiddingCategoryData({selector => $selector});

  if ($results) {
    # %bidding_categories is a hash where key=dimension ID
    # and value=a hash of properties
    my %bidding_categories = ();
    my @root_categories    = ();
    foreach my $product_bidding_category_data (@{$results}) {
      my $id =
        $product_bidding_category_data->get_dimensionValue()->get_value();
      my $parent_id;
      my $name =
        $product_bidding_category_data->get_displayValue()->[0]->get_value();
      if ($product_bidding_category_data->get_parentDimensionValue()) {
        $parent_id =
          $product_bidding_category_data->get_parentDimensionValue()
          ->get_value();
      }

      if (!(exists $bidding_categories{$id})) {
        $bidding_categories{$id} = {};
      }

      my $category = $bidding_categories{$id};

      if ($parent_id) {
        if (!(exists $bidding_categories{$parent_id})) {
          $bidding_categories{$parent_id} = {};
        }
        my $parent = $bidding_categories{$parent_id};

        if (!(exists $parent->{"children"})) {
          $parent->{"children"} = [];
        }
        my $children = $parent->{"children"};
        push $children, $category;
      } else {
        push @root_categories, $category;
      }

      $category->{"id"}   = $id;
      $category->{"name"} = $name;
    }
    display_categories(\@root_categories, "");
  } else {
    print "No product bidding category data items were found.\n";
  }

  return 1;
}

sub display_categories {
  my $categories = shift;
  my $prefix     = shift;
  foreach my $category (@{$categories}) {
    printf "%s%s [%s]\n", $prefix, $category->{"name"}, $category->{"id"};
    if (exists $category->{"children"}) {
      my $category_name = $category->{"name"};
      my $children      = $category->{"children"};
      display_categories($children, "${prefix}${category_name} > ");
    }
  }
}

# Don't run the example if the file is being included.
if (abs_path($0) ne abs_path(__FILE__)) {
  return 1;
}

# Log SOAP XML request, response and API errors.
Google::Ads::AdWords::Logging::enable_all_logging();

# Get AdWords Client, credentials will be read from ~/adwords.properties.
my $client = Google::Ads::AdWords::Client->new({version => "v201809"});

# By default examples are set to die on any server returned fault.
$client->set_die_on_faults(1);

# Call the example
get_product_category_taxonomy($client);
get_product_category_taxonomy.pl