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));
            }
        }
    }
}