The AdWords API will sunset on April 27, 2022. Migrate to the Google Ads API to take advantage of the latest Google Ads features.

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

// 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.

using Google.Api.Ads.AdWords.Lib;
using Google.Api.Ads.AdWords.Util.Shopping.v201809;
using Google.Api.Ads.AdWords.v201809;

using System;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example creates a ProductPartition tree.
    /// </summary>
    public class AddProductPartitionTree : ExampleBase
    {
        /// <summary>
        /// Main method, to run this code example as a standalone application.
        /// </summary>
        /// <param name="args">The command line arguments.</param>
        public static void Main(string[] args)
        {
            AddProductPartitionTree codeExample = new AddProductPartitionTree();
            Console.WriteLine(codeExample.Description);
            try
            {
                long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE");
                codeExample.Run(new AdWordsUser(), adGroupId);
            }
            catch (Exception e)
            {
                Console.WriteLine("An exception occurred while running this code example. {0}",
                    ExampleUtilities.FormatException(e));
            }
        }

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get { return "This code example creates a ProductPartition tree."; }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupId">The ad group to which product partition is
        /// added.</param>
        public void Run(AdWordsUser user, long adGroupId)
        {
            using (AdGroupCriterionService adGroupCriterionService =
                (AdGroupCriterionService) user.GetService(AdWordsService.v201809
                    .AdGroupCriterionService))
            {
                // Build a new ProductPartitionTree using the ad group's current set of criteria.
                ProductPartitionTree partitionTree =
                    ProductPartitionTree.DownloadAdGroupTree(user, adGroupId);

                Console.WriteLine("Original tree: {0}", partitionTree);

                // Clear out any existing criteria.
                ProductPartitionNode rootNode = partitionTree.Root.RemoveAllChildren();

                // Make the root node a subdivision.
                rootNode = rootNode.AsSubdivision();

                // Add a unit node for condition = NEW.
                ProductPartitionNode newConditionNode = rootNode.AddChild(
                    ProductDimensions.CreateCanonicalCondition(ProductCanonicalConditionCondition
                        .NEW));
                newConditionNode.AsBiddableUnit().CpcBid = 200000;

                ProductPartitionNode usedConditionNode = rootNode.AddChild(
                    ProductDimensions.CreateCanonicalCondition(ProductCanonicalConditionCondition
                        .USED));
                usedConditionNode.AsBiddableUnit().CpcBid = 100000;

                // Add a subdivision node for condition = null (everything else).
                ProductPartitionNode otherConditionNode = rootNode
                    .AddChild(ProductDimensions.CreateCanonicalCondition()).AsSubdivision();

                // Add a unit node under condition = null for brand = "CoolBrand".
                ProductPartitionNode coolBrandNode =
                    otherConditionNode.AddChild(ProductDimensions.CreateBrand("CoolBrand"));
                coolBrandNode.AsBiddableUnit().CpcBid = 900000L;

                // Add a unit node under condition = null for brand = "CheapBrand".
                ProductPartitionNode cheapBrandNode =
                    otherConditionNode.AddChild(ProductDimensions.CreateBrand("CheapBrand"));
                cheapBrandNode.AsBiddableUnit().CpcBid = 10000L;

                // Add a subdivision node under condition = null for brand = null (everything else).
                ProductPartitionNode otherBrandNode = otherConditionNode
                    .AddChild(ProductDimensions.CreateBrand(null)).AsSubdivision();

                // Add unit nodes under condition = null/brand = null.
                // The value for each bidding category is a fixed ID for a specific
                // category. You can retrieve IDs for categories from the ConstantDataService.
                // See the 'GetProductCategoryTaxonomy' example for more details.

                // Add a unit node under condition = null/brand = null for product type
                // level 1 = 'Luggage & Bags'.
                ProductPartitionNode luggageAndBagNode =
                    otherBrandNode.AddChild(ProductDimensions.CreateBiddingCategory(
                        ProductDimensionType.BIDDING_CATEGORY_L1, -5914235892932915235L));
                luggageAndBagNode.AsBiddableUnit().CpcBid = 750000L;

                // Add a unit node under condition = null/brand = null for product type
                // level 1 = null (everything else).
                ProductPartitionNode everythingElseNode =
                    otherBrandNode.AddChild(
                        ProductDimensions.CreateBiddingCategory(ProductDimensionType
                            .BIDDING_CATEGORY_L1));
                everythingElseNode.AsBiddableUnit().CpcBid = 110000L;

                try
                {
                    // Make the mutate request, using the operations returned by the
                    // ProductPartitionTree.
                    AdGroupCriterionOperation[] mutateOperations =
                        partitionTree.GetMutateOperations();

                    if (mutateOperations.Length == 0)
                    {
                        Console.WriteLine(
                            "Skipping the mutate call because the original tree and the " +
                            "current tree are logically identical.");
                    }
                    else
                    {
                        adGroupCriterionService.mutate(mutateOperations);
                    }

                    // The request was successful, so create a new ProductPartitionTree based on
                    // the updated state of the ad group.
                    partitionTree = ProductPartitionTree.DownloadAdGroupTree(user, adGroupId);

                    Console.WriteLine("Final tree: {0}", partitionTree);
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException(
                        "Failed to set shopping product partition.", e);
                }
            }
        }
    }
}

Set a product scope for a campaign

// 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.

using Google.Api.Ads.AdWords.Lib;
using Google.Api.Ads.AdWords.v201809;

using System;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example restricts the products that will be included in the
    /// campaign by setting a ProductScope.
    /// </summary>
    public class AddProductScope : ExampleBase
    {
        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get
            {
                return "This code example restricts the products that will be included in the " +
                    "campaign by setting a ProductScope.";
            }
        }

        /// <summary>
        /// Main method, to run this code example as a standalone application.
        /// </summary>
        /// <param name="args">The command line arguments.</param>
        public static void Main(string[] args)
        {
            AddProductScope codeExample = new AddProductScope();
            Console.WriteLine(codeExample.Description);
            try
            {
                long campaignId = long.Parse("INSERT_CAMPAIGN_ID_HERE");
                codeExample.Run(new AdWordsUser(), campaignId);
            }
            catch (Exception e)
            {
                Console.WriteLine("An exception occurred while running this code example. {0}",
                    ExampleUtilities.FormatException(e));
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="campaignId">The campaign id to add product scope.</param>
        public void Run(AdWordsUser user, long campaignId)
        {
            using (CampaignCriterionService campaignCriterionService =
                (CampaignCriterionService) user.GetService(AdWordsService.v201809
                    .CampaignCriterionService))
            {
                ProductScope productScope = new ProductScope();
                // 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.
                ProductBrand nexusBrand = new ProductBrand
                {
                    value = "Nexus"
                };

                ProductCanonicalCondition newProducts = new ProductCanonicalCondition
                {
                    condition = ProductCanonicalConditionCondition.NEW
                };

                ProductCustomAttribute customAttribute = new ProductCustomAttribute
                {
                    type = ProductDimensionType.CUSTOM_ATTRIBUTE_0,
                    value = "my attribute value"
                };

                ProductOfferId bookOffer = new ProductOfferId
                {
                    value = "book1"
                };

                ProductType mediaProducts = new ProductType
                {
                    type = ProductDimensionType.PRODUCT_TYPE_L1,
                    value = "Media"
                };

                ProductType bookProducts = new ProductType
                {
                    type = ProductDimensionType.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 'GetProductCategoryTaxonomy' example
                // for more details.
                ProductBiddingCategory luggageBiddingCategory = new ProductBiddingCategory
                {
                    type = ProductDimensionType.BIDDING_CATEGORY_L1,
                    value = -5914235892932915235
                };

                productScope.dimensions = new ProductDimension[]
                {
                    nexusBrand,
                    newProducts,
                    bookOffer,
                    mediaProducts,
                    luggageBiddingCategory
                };

                CampaignCriterion campaignCriterion = new CampaignCriterion
                {
                    campaignId = campaignId,
                    criterion = productScope
                };

                // Create operation.
                CampaignCriterionOperation operation = new CampaignCriterionOperation
                {
                    operand = campaignCriterion,
                    @operator = Operator.ADD
                };

                try
                {
                    // Make the mutate request.
                    CampaignCriterionReturnValue result = campaignCriterionService.mutate(
                        new CampaignCriterionOperation[]
                        {
                            operation
                        });

                    Console.WriteLine("Created a ProductScope criterion with ID '{0}'",
                        result.value[0].criterion.id);
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to set shopping product scope.",
                        e);
                }
            }
        }
    }
}

Add a Shopping campaign

// 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.

using Google.Api.Ads.AdWords.Lib;
using Google.Api.Ads.AdWords.Util.Shopping.v201809;
using Google.Api.Ads.AdWords.v201809;

using System;
using System.Collections.Generic;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example adds a Shopping campaign.
    /// </summary>
    public class AddShoppingCampaign : ExampleBase
    {
        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get { return "This code example adds a Shopping campaign."; }
        }

        /// <summary>
        /// Main method, to run this code example as a standalone application.
        /// </summary>
        /// <param name="args">The command line arguments.</param>
        public static void Main(string[] args)
        {
            AddShoppingCampaign codeExample = new AddShoppingCampaign();
            Console.WriteLine(codeExample.Description);
            try
            {
                long budgetId = long.Parse("INSERT_BUDGET_ID_HERE");
                long merchantId = long.Parse("INSERT_MERCHANT_ID_HERE");
                bool createDefaultPartition = false;
                codeExample.Run(new AdWordsUser(), budgetId, merchantId, createDefaultPartition);
            }
            catch (Exception e)
            {
                Console.WriteLine("An exception occurred while running this code example. {0}",
                    ExampleUtilities.FormatException(e));
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="budgetId">The budget id.</param>
        /// <param name="merchantId">The Merchant Center account ID.</param>
        /// <param name="createDefaultPartition">If set to true, a default
        /// partition will be created. If running the AddProductPartition.cs
        /// example right after this example, make sure this stays set to
        /// false.</param>
        public void Run(AdWordsUser user, long budgetId, long merchantId,
            bool createDefaultPartition)
        {
            try
            {
                Campaign campaign = CreateCampaign(user, budgetId, merchantId);
                Console.WriteLine("Campaign with name '{0}' and ID '{1}' was added.", campaign.name,
                    campaign.id);

                AdGroup adGroup = CreateAdGroup(user, campaign.id);
                Console.WriteLine("Ad group with name '{0}' and ID '{1}' was added.", adGroup.name,
                    adGroup.id);

                AdGroupAd adGroupAd = CreateProductAd(user, adGroup.id);
                Console.WriteLine("Product ad with ID {0}' was added.", adGroupAd.ad.id);

                if (createDefaultPartition)
                {
                    CreateDefaultPartitionTree(user, adGroup.id);
                }
            }
            catch (Exception e)
            {
                throw new System.ApplicationException("Failed to create shopping campaign.", e);
            }
        }

        /// <summary>
        /// Creates the default partition.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupId">The ad group ID.</param>
        private void CreateDefaultPartitionTree(AdWordsUser user, long adGroupId)
        {
            using (AdGroupCriterionService adGroupCriterionService =
                (AdGroupCriterionService) user.GetService(AdWordsService.v201809
                    .AdGroupCriterionService))
            {
                // Build a new ProductPartitionTree using an empty set of criteria.
                ProductPartitionTree partitionTree =
                    ProductPartitionTree.CreateAdGroupTree(adGroupId, new List<AdGroupCriterion>());
                partitionTree.Root.AsBiddableUnit().CpcBid = 1000000;

                try
                {
                    // Make the mutate request, using the operations returned by the
                    // ProductPartitionTree.
                    AdGroupCriterionOperation[] mutateOperations =
                        partitionTree.GetMutateOperations();

                    if (mutateOperations.Length == 0)
                    {
                        Console.WriteLine(
                            "Skipping the mutate call because the original tree and the " +
                            "current tree are logically identical.");
                    }
                    else
                    {
                        adGroupCriterionService.mutate(mutateOperations);
                    }

                    // The request was successful, so create a new ProductPartitionTree based on
                    // the updated state of the ad group.
                    partitionTree = ProductPartitionTree.DownloadAdGroupTree(user, adGroupId);

                    Console.WriteLine("Final tree: {0}", partitionTree);
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException(
                        "Failed to set shopping product partition.", e);
                }
            }
        }

        /// <summary>
        /// Creates the Product Ad.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupId">The ad group ID.</param>
        /// <returns>The Product Ad.</returns>
        private static AdGroupAd CreateProductAd(AdWordsUser user, long adGroupId)
        {
            using (AdGroupAdService adGroupAdService =
                (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService))
            {
                // Create product ad.
                ProductAd productAd = new ProductAd();

                // Create ad group ad.
                AdGroupAd adGroupAd = new AdGroupAd
                {
                    adGroupId = adGroupId,
                    ad = productAd
                };

                // Create operation.
                AdGroupAdOperation operation = new AdGroupAdOperation
                {
                    operand = adGroupAd,
                    @operator = Operator.ADD
                };

                // Make the mutate request.
                AdGroupAdReturnValue retval = adGroupAdService.mutate(new AdGroupAdOperation[]
                {
                    operation
                });
                return retval.value[0];
            }
        }

        /// <summary>
        /// Creates the ad group in a Shopping campaign.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="campaignId">The campaign ID.</param>
        /// <returns>The ad group.</returns>
        private static AdGroup CreateAdGroup(AdWordsUser user, long campaignId)
        {
            using (AdGroupService adGroupService =
                (AdGroupService) user.GetService(AdWordsService.v201809.AdGroupService))
            {
                // Create ad group.
                AdGroup adGroup = new AdGroup
                {
                    campaignId = campaignId,
                    name = "Ad Group #" + ExampleUtilities.GetRandomString()
                };

                // Create operation.
                AdGroupOperation operation = new AdGroupOperation
                {
                    operand = adGroup,
                    @operator = Operator.ADD
                };

                // Make the mutate request.
                AdGroupReturnValue retval = adGroupService.mutate(new AdGroupOperation[]
                {
                    operation
                });
                return retval.value[0];
            }
        }

        /// <summary>
        /// Creates the shopping campaign.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="budgetId">The budget id.</param>
        /// <param name="merchantId">The Merchant Center id.</param>
        /// <returns>The Shopping campaign.</returns>
        private static Campaign CreateCampaign(AdWordsUser user, long budgetId, long merchantId)
        {
            using (CampaignService campaignService =
                (CampaignService) user.GetService(AdWordsService.v201809.CampaignService))
            {
                // Create campaign.
                Campaign campaign = new Campaign
                {
                    name = "Shopping campaign #" + ExampleUtilities.GetRandomString(),

                    // The advertisingChannelType is what makes this a Shopping campaign.
                    advertisingChannelType = AdvertisingChannelType.SHOPPING,

                    // 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 shared budget (required).
                    budget = new Budget
                    {
                        budgetId = budgetId
                    }
                };

                // Set bidding strategy (required).
                BiddingStrategyConfiguration biddingStrategyConfiguration =
                    new BiddingStrategyConfiguration
                    {
                        biddingStrategyType = BiddingStrategyType.MANUAL_CPC
                    };

                campaign.biddingStrategyConfiguration = biddingStrategyConfiguration;

                // All Shopping campaigns need a ShoppingSetting.
                ShoppingSetting shoppingSetting = new ShoppingSetting
                {
                    salesCountry = "US",
                    campaignPriority = 0,
                    merchantId = merchantId,

                    // Set to "true" to enable Local Inventory Ads in your campaign.
                    enableLocal = true
                };
                campaign.settings = new Setting[]
                {
                    shoppingSetting
                };

                // Create operation.
                CampaignOperation campaignOperation = new CampaignOperation
                {
                    operand = campaign,
                    @operator = Operator.ADD
                };

                // Make the mutate request.
                CampaignReturnValue retval = campaignService.mutate(new CampaignOperation[]
                {
                    campaignOperation
                });

                return retval.value[0];
            }
        }
    }
}

Add a Smart Shopping campaign

// 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.

using Google.Api.Ads.AdWords.Lib;
using Google.Api.Ads.AdWords.Util.Shopping.v201809;
using Google.Api.Ads.AdWords.v201809;

using System;
using System.Collections.Generic;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example adds a Smart Shopping campaign with an ad group and ad group ad.
    /// </summary>
    public class AddSmartShoppingAd : ExampleBase
    {
        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get
            {
                return "This code example adds a Smart Shopping campaign with an ad group and " +
                    "ad group ad.";
            }
        }

        /// <summary>
        /// Main method, to run this code example as a standalone application.
        /// </summary>
        /// <param name="args">The command line arguments.</param>
        public static void Main(string[] args)
        {
            AddSmartShoppingAd codeExample = new AddSmartShoppingAd();
            Console.WriteLine(codeExample.Description);
            try
            {
                long merchantId = long.Parse("INSERT_MERCHANT_ID_HERE");
                bool createDefaultPartition = false;
                codeExample.Run(new AdWordsUser(), merchantId, createDefaultPartition);
            }
            catch (Exception e)
            {
                Console.WriteLine("An exception occurred while running this code example. {0}",
                    ExampleUtilities.FormatException(e));
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The Google Ads user.</param>
        /// <param name="merchantId">The Merchant Center ID for the new campaign.</param>
        /// <param name="createDefaultPartition">If <c>true</c>, a default product partition for
        /// all products will be created.</param>
        public void Run(AdWordsUser user, long merchantId, bool createDefaultPartition)
        {
            Budget budget = CreateBudget(user);
            Campaign campaign =
                CreateSmartShoppingCampaign(user, budget.budgetId, merchantId);
            AdGroup adGroup = CreateSmartShoppingAdGroup(user, campaign.id);
            CreateSmartShoppingAd(user, adGroup.id);
            if (createDefaultPartition)
            {
                CreateDefaultPartition(user, adGroup.id);
            }
        }

        /// <summary>
        /// Creates a non-shared budget for a Smart Shopping campaign. Smart Shopping campaigns
        /// support only non-shared budgets.
        /// </summary>
        /// <param name="user">The Google Ads user.</param>
        /// <returns>The newly created budget.</returns>
        private Budget CreateBudget(AdWordsUser user)
        {
            using (BudgetService budgetService =
               (BudgetService) user.GetService(AdWordsService.v201809.BudgetService))
            {
                // Create a budget.
                Budget budget = new Budget()
                {
                    name = "Interplanetary Cruise #" + ExampleUtilities.GetRandomString(),
                    amount = new Money()
                    {
                        // This budget equals 50.00 units of your account's currency, e.g.,
                        // 50 USD if your currency is USD.
                        microAmount = 50_000_000L
                    },
                    deliveryMethod = BudgetBudgetDeliveryMethod.STANDARD,
                    // Non-shared budgets are required for Smart Shopping campaigns.
                    isExplicitlyShared = false
                };

                // Create operation.
                BudgetOperation budgetOperation = new BudgetOperation()
                {
                    operand = budget,
                    @operator = Operator.ADD
                };

                // Add the budget.
                Budget newBudget = budgetService.mutate(
                    new BudgetOperation[] { budgetOperation }).value[0];
                Console.WriteLine($"Budget with name '{newBudget.name}' and ID " +
                    $"{newBudget.budgetId} was added.");
                return newBudget;
            }
        }

        /// <summary>
        /// Creates a Smart Shopping campaign.
        /// </summary>
        /// <param name="user">The Google Ads user.</param>
        /// <param name="budgetId">The budget ID.</param>
        /// <param name="merchantId">The merchant center account ID.</param>
        /// <returns>The newly created campaign.</returns>
        private Campaign CreateSmartShoppingCampaign(AdWordsUser user, long budgetId,
            long merchantId)
        {
            using (CampaignService campaignService =
                (CampaignService) user.GetService(AdWordsService.v201809.CampaignService))
            {
                // Create a campaign with required and optional settings.
                Campaign campaign = new Campaign()
                {
                    name = "Smart Shopping campaign #" + ExampleUtilities.GetRandomString(),

                    // The advertisingChannelType is what makes this a Shopping campaign.
                    advertisingChannelType = AdvertisingChannelType.SHOPPING,

                    // Sets the advertisingChannelSubType to SHOPPING_GOAL_OPTIMIZED_ADS to
                    // make this a Smart Shopping campaign.
                    advertisingChannelSubType =
                        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 = CampaignStatus.PAUSED,

                    // Set a budget.
                    budget = new Budget()
                    {
                        budgetId = budgetId
                    },

                    // Set bidding strategy. Only MAXIMIZE_CONVERSION_VALUE is supported.
                    biddingStrategyConfiguration = new BiddingStrategyConfiguration()
                    {
                        biddingStrategyType = BiddingStrategyType.MAXIMIZE_CONVERSION_VALUE
                    },

                    // All Shopping campaigns need a ShoppingSetting.
                    settings = new Setting[]
                    {
                        new ShoppingSetting()
                        {
                            salesCountry = "US",
                            merchantId = merchantId
                        }
                    }
                };

                // Create operation.
                CampaignOperation campaignOperation = new CampaignOperation()
                {
                    operand = campaign,
                    @operator = Operator.ADD
                };

                // Make the mutate request and retrieve the result.
                Campaign newCampaign =
                    campaignService.mutate(new CampaignOperation[] { campaignOperation }).value[0];

                // Display result.
                Console.WriteLine($"Smart Shopping campaign with name '{newCampaign.name}' and " +
                    $"ID {newCampaign.id} was added.");
                return newCampaign;
            }
        }

        /// <summary>
        /// Creates a Smart Shopping ad group by setting the ad group type to
        /// SHOPPING_GOAL_OPTIMIZED_ADS.
        /// </summary>
        /// <param name="user">The Google Ads user.</param>
        /// <param name="campaignId">The campaign ID.</param>
        private AdGroup CreateSmartShoppingAdGroup(AdWordsUser user, long campaignId)
        {
            using (AdGroupService adGroupService =
                (AdGroupService) user.GetService(AdWordsService.v201809.AdGroupService))
            {
                // Create ad group.
                AdGroup adGroup = new AdGroup()
                {
                    campaignId = campaignId,
                    name = "Smart Shopping ad group #" + ExampleUtilities.GetRandomString(),

                    // Set the ad group type to SHOPPING_GOAL_OPTIMIZED_ADS.
                    adGroupType = AdGroupType.SHOPPING_GOAL_OPTIMIZED_ADS
                };

                // Create operation.
                AdGroupOperation adGroupOperation = new AdGroupOperation()
                {
                    operand = adGroup,
                    @operator = Operator.ADD
                };


                // Make the mutate request.
                AdGroup newAdGroup =
                    adGroupService.mutate(new AdGroupOperation[] { adGroupOperation }).value[0];

                // Display result.
                Console.WriteLine($"Smart Shopping ad group with name '{adGroup.name}' and " +
                    $"ID {adGroup.id} was added.");

                return newAdGroup;
            }
        }

        /// <summary>
        /// Creates the smart shopping ad.
        /// </summary>
        /// <param name="user">The Google Ads user.</param>
        /// <param name="adGroupId">The ad group ID.</param>
        private void CreateSmartShoppingAd(AdWordsUser user, long adGroupId)
        {
            using (AdGroupAdService adGroupAdService =
                (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService))
            {
                // Create ad group ad.
                AdGroupAd adGroupAd = new AdGroupAd()
                {
                    adGroupId = adGroupId,
                    // Create a Smart Shopping ad (Goal-optimized Shopping ad).
                    ad = new GoalOptimizedShoppingAd() { }
                };


                // Create operation.
                AdGroupAdOperation adGroupAdOperation = new AdGroupAdOperation()
                {
                    operand = adGroupAd,
                    @operator = Operator.ADD
                };


                // Make the mutate request.
                AdGroupAd newAdGroupAd = adGroupAdService.mutate(
                    new AdGroupAdOperation[] { adGroupAdOperation }).value[0];

                // Display result.
                Console.WriteLine($"Smart Shopping ad with ID {newAdGroupAd.ad.id} was added.");
            }
        }

        /// <summary>
        /// Creates the default partition.
        /// </summary>
        /// <param name="user">The user.</param>
        /// <param name="adGroupId">The ad group ID.</param>
        private void CreateDefaultPartition(AdWordsUser user, long adGroupId)
        {
            // Create an ad group criterion for 'All products' using the ProductPartitionTree
            // utility.
            ProductPartitionTree productPartitionTree =
                ProductPartitionTree.CreateAdGroupTree(adGroupId, new List<AdGroupCriterion>());
            AdGroupCriterionOperation[] mutateOperations =
                productPartitionTree.GetMutateOperations();

            using (AdGroupCriterionService adGroupCriterionService =
                (AdGroupCriterionService) user.GetService(
                    AdWordsService.v201809.AdGroupCriterionService))
            {
                AdGroupCriterionReturnValue adGroupCriterionResult =
                    adGroupCriterionService.mutate(mutateOperations);

                // Display result.
                foreach (AdGroupCriterion adGroupCriterion in adGroupCriterionResult.value)
                {
                    Console.WriteLine(
                        $"Ad group criterion with ID {adGroupCriterion.criterion.id} in ad " +
                        $"group with ID {adGroupCriterion.adGroupId} was added.");
                }
            }

        }
    }
}

Get the set of product bidding categories

// 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.

using Google.Api.Ads.AdWords.Lib;
using Google.Api.Ads.AdWords.v201809;

using System;
using System.Collections.Generic;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example fetches the set of valid ProductBiddingCategories.
    /// </summary>
    public class GetProductCategoryTaxonomy : ExampleBase
    {
        /// <summary>
        /// Stores details about a product category and its hierarchy.
        /// </summary>
        private class ProductCategory
        {
            /// <summary>
            /// The product category id.
            /// </summary>
            private long id;

            /// <summary>
            /// The product category name.
            /// </summary>
            private string name;

            /// <summary>
            /// The product category children.
            /// </summary>
            private List<ProductCategory> children = new List<ProductCategory>();

            /// <summary>
            /// Gets or sets the product category id.
            /// </summary>
            public long Id
            {
                get { return id; }
                set { id = value; }
            }

            /// <summary>
            /// Gets or sets the product category name.
            /// </summary>
            public string Name
            {
                get { return name; }
                set { name = value; }
            }

            /// <summary>
            /// Gets or sets the product category children.
            /// </summary>
            public List<ProductCategory> Children
            {
                get { return children; }
            }
        }

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get { return "This code example fetches the set of valid ProductBiddingCategories."; }
        }

        /// <summary>
        /// Main method, to run this code example as a standalone application.
        /// </summary>
        /// <param name="args">The command line arguments.</param>
        public static void Main(string[] args)
        {
            GetProductCategoryTaxonomy codeExample = new GetProductCategoryTaxonomy();
            Console.WriteLine(codeExample.Description);
            try
            {
                codeExample.Run(new AdWordsUser());
            }
            catch (Exception e)
            {
                Console.WriteLine("An exception occurred while running this code example. {0}",
                    ExampleUtilities.FormatException(e));
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        public void Run(AdWordsUser user)
        {
            using (ConstantDataService constantDataService =
                (ConstantDataService) user.GetService(AdWordsService.v201809.ConstantDataService))
            {
                Selector selector = new Selector()
                {
                    predicates = new Predicate[]
                    {
                        Predicate.In(ProductBiddingCategoryData.Fields.Country, new string[]
                        {
                            "US"
                        })
                    }
                };

                try
                {
                    ProductBiddingCategoryData[] results =
                        constantDataService.getProductBiddingCategoryData(selector);

                    Dictionary<long, ProductCategory> biddingCategories =
                        new Dictionary<long, ProductCategory>();
                    List<ProductCategory> rootCategories = new List<ProductCategory>();

                    foreach (ProductBiddingCategoryData productBiddingCategory in results)
                    {
                        long id = productBiddingCategory.dimensionValue.value;
                        long parentId = 0;
                        string name = productBiddingCategory.displayValue[0].value;

                        if (productBiddingCategory.parentDimensionValue != null)
                        {
                            parentId = productBiddingCategory.parentDimensionValue.value;
                        }

                        if (!biddingCategories.ContainsKey(id))
                        {
                            biddingCategories.Add(id, new ProductCategory());
                        }

                        ProductCategory category = biddingCategories[id];

                        if (parentId != 0)
                        {
                            if (!biddingCategories.ContainsKey(parentId))
                            {
                                biddingCategories.Add(parentId, new ProductCategory());
                            }

                            ProductCategory parent = biddingCategories[parentId];
                            parent.Children.Add(category);
                        }
                        else
                        {
                            rootCategories.Add(category);
                        }

                        category.Id = id;
                        category.Name = name;
                    }

                    DisplayProductCategories(rootCategories, "");
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException(
                        "Failed to set shopping product category.", e);
                }
            }
        }

        /// <summary>
        /// Displays the product categories.
        /// </summary>
        /// <param name="categories">The product categories.</param>
        /// <param name="prefix">The prefix for display purposes.</param>
        private void DisplayProductCategories(List<ProductCategory> categories, string prefix)
        {
            foreach (ProductCategory category in categories)
            {
                Console.WriteLine("{0}{1} [{2}]", prefix, category.Name, category.Id);
                DisplayProductCategories(category.Children,
                    string.Format("{0}{1} > ", prefix, category.Name));
            }
        }
    }
}