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

<?php
/**
 * 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.
 */

namespace Google\AdsApi\Examples\AdWords\v201809\ShoppingCampaigns;

require __DIR__ . '/../../../../vendor/autoload.php';

use Google\AdsApi\AdWords\AdWordsServices;
use Google\AdsApi\AdWords\AdWordsSession;
use Google\AdsApi\AdWords\AdWordsSessionBuilder;
use Google\AdsApi\AdWords\Shopping\v201809\ProductPartitions;
use Google\AdsApi\AdWords\v201809\cm\AdGroupCriterionService;
use Google\AdsApi\AdWords\v201809\cm\ProductBiddingCategory;
use Google\AdsApi\AdWords\v201809\cm\ProductBrand;
use Google\AdsApi\AdWords\v201809\cm\ProductCanonicalCondition;
use Google\AdsApi\AdWords\v201809\cm\ProductCanonicalConditionCondition;
use Google\AdsApi\AdWords\v201809\cm\ProductDimensionType;
use Google\AdsApi\Common\OAuth2TokenBuilder;

/**
 * This example creates a product partition tree.
 */
class AddProductPartitionTree
{

    const AD_GROUP_ID = 'INSERT_AD_GROUP_ID_HERE';

    public static function runExample(
        AdWordsServices $adWordsServices,
        AdWordsSession $session,
        $adGroupId
    ) {
        // The most trivial partition tree has only a unit node as the root:
        //   $productPartitions->createBiddableUnit(null, null, 100000);

        $operations = [];
        $root = ProductPartitions::createSubdivision();
        $criterion = ProductPartitions::asBiddableAdGroupCriterion($adGroupId, $root);
        $operation = ProductPartitions::createAddOperation($criterion);
        $operations[] = $operation;

        $newCondition = new ProductCanonicalCondition();
        $newCondition->setCondition(ProductCanonicalConditionCondition::NEW_VALUE);
        $newConditionUnit = ProductPartitions::createUnit($root, $newCondition);
        $criterion = ProductPartitions::asBiddableAdGroupCriterion(
            $adGroupId,
            $newConditionUnit,
            200000
        );
        $operation = ProductPartitions::createAddOperation($criterion);
        $operations[] = $operation;

        $usedCondition = new ProductCanonicalCondition();
        $usedCondition->setCondition(ProductCanonicalConditionCondition::USED);
        $usedConditionUnit = ProductPartitions::createUnit($root, $usedCondition);
        $criterion = ProductPartitions::asBiddableAdGroupCriterion(
            $adGroupId,
            $usedConditionUnit,
            100000
        );
        $operation = ProductPartitions::createAddOperation($criterion);
        $operations[] = $operation;

        $otherCondition = ProductPartitions::createSubdivision(
            $root,
            new ProductCanonicalCondition()
        );
        $criterion = ProductPartitions::asBiddableAdGroupCriterion(
            $adGroupId,
            $otherCondition
        );
        $operation = ProductPartitions::createAddOperation($criterion);
        $operations[] = $operation;

        $coolBrand = new ProductBrand();
        $coolBrand->setValue('CoolBrand');
        $coolBrandUnit = ProductPartitions::createUnit($otherCondition, $coolBrand);
        $criterion = ProductPartitions::asBiddableAdGroupCriterion(
            $adGroupId,
            $coolBrandUnit,
            900000
        );
        $operation = ProductPartitions::createAddOperation($criterion);
        $operations[] = $operation;

        $cheapBrand = new ProductBrand();
        $cheapBrand->setValue('CheapBrand');
        $cheapBrandUnit = ProductPartitions::createUnit($otherCondition, $cheapBrand);
        $criterion = ProductPartitions::asBiddableAdGroupCriterion(
            $adGroupId,
            $cheapBrandUnit,
            10000
        );
        $operation = ProductPartitions::createAddOperation($criterion);
        $operations[] = $operation;

        $otherBrand = ProductPartitions::createSubdivision(
            $otherCondition,
            new ProductBrand()
        );
        $criterion = ProductPartitions::asBiddableAdGroupCriterion(
            $adGroupId,
            $otherBrand
        );
        $operation = ProductPartitions::createAddOperation($criterion);
        $operations[] = $operation;

        // 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 = new ProductBiddingCategory();
        $productBiddingCategory->setType(ProductDimensionType::BIDDING_CATEGORY_L1);
        $productBiddingCategory->setValue(-5914235892932915235);
        $productBiddingCategoryUnit = ProductPartitions::createUnit($otherBrand, $productBiddingCategory);
        $criterion = ProductPartitions::asBiddableAdGroupCriterion(
            $adGroupId,
            $productBiddingCategoryUnit,
            750000
        );
        $operation = ProductPartitions::createAddOperation($criterion);
        $operations[] = $operation;

        $productBiddingCategory = new ProductBiddingCategory();
        $productBiddingCategory->setType(ProductDimensionType::BIDDING_CATEGORY_L1);
        $productBiddingCategoryUnit = ProductPartitions::createUnit($otherBrand, $productBiddingCategory);
        $criterion = ProductPartitions::asBiddableAdGroupCriterion(
            $adGroupId,
            $productBiddingCategoryUnit,
            110000
        );
        $operation = ProductPartitions::createAddOperation($criterion);
        $operations[] = $operation;

        $adGroupCriterionService = $adWordsServices->get($session, AdGroupCriterionService::class);

        // Creates ad group criteria on the server.
        $adGroupCriterionService->mutate($operations);

        // Display the production partition tree.
        printf(
            "%s\n",
            ProductPartitions::showAdGroupTree(
                $adWordsServices,
                $session,
                $adGroupId
            )
        );
    }

    public static function main()
    {
        // Generate a refreshable OAuth2 credential for authentication.
        $oAuth2Credential = (new OAuth2TokenBuilder())->fromFile()->build();

        // Construct an API session configured from a properties file and the
        // OAuth2 credentials above.
        $session = (new AdWordsSessionBuilder())->fromFile()->withOAuth2Credential($oAuth2Credential)->build();
        self::runExample(
            new AdWordsServices(),
            $session,
            intval(self::AD_GROUP_ID)
        );
    }
}

AddProductPartitionTree::main();

Set a product scope for a campaign

<?php
/**
 * 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.
 */

namespace Google\AdsApi\Examples\AdWords\v201809\ShoppingCampaigns;

require __DIR__ . '/../../../../vendor/autoload.php';

use Google\AdsApi\AdWords\AdWordsServices;
use Google\AdsApi\AdWords\AdWordsSession;
use Google\AdsApi\AdWords\AdWordsSessionBuilder;
use Google\AdsApi\AdWords\v201809\cm\CampaignCriterion;
use Google\AdsApi\AdWords\v201809\cm\CampaignCriterionOperation;
use Google\AdsApi\AdWords\v201809\cm\CampaignCriterionService;
use Google\AdsApi\AdWords\v201809\cm\Operator;
use Google\AdsApi\AdWords\v201809\cm\ProductBiddingCategory;
use Google\AdsApi\AdWords\v201809\cm\ProductBrand;
use Google\AdsApi\AdWords\v201809\cm\ProductCanonicalCondition;
use Google\AdsApi\AdWords\v201809\cm\ProductCanonicalConditionCondition;
use Google\AdsApi\AdWords\v201809\cm\ProductCustomAttribute;
use Google\AdsApi\AdWords\v201809\cm\ProductDimensionType;
use Google\AdsApi\AdWords\v201809\cm\ProductOfferId;
use Google\AdsApi\AdWords\v201809\cm\ProductScope;
use Google\AdsApi\AdWords\v201809\cm\ProductType;
use Google\AdsApi\Common\OAuth2TokenBuilder;

/**
 * This example restricts the products that will be included in the campaign by
 * setting a ProductScope.
 */
class AddProductScope
{

    const CAMPAIGN_ID = 'INSERT_CAMPAIGN_ID_HERE';

    public static function runExample(
        AdWordsServices $adWordsServices,
        AdWordsSession $session,
        $campaignId
    ) {
        $campaignCriterionService = $adWordsServices->get($session, CampaignCriterionService::class);

        $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 = new ProductBrand();
        $productBrand->setValue('Nexus');

        $productCanonicalCondition = new ProductCanonicalCondition();
        $productCanonicalCondition->setCondition(
            ProductCanonicalConditionCondition::NEW_VALUE
        );

        $productCustomAttribute = new ProductCustomAttribute();
        $productCustomAttribute->setType(ProductDimensionType::CUSTOM_ATTRIBUTE_0);
        $productCustomAttribute->setValue('my attribute value');

        $productOfferId = new ProductOfferId();
        $productOfferId->setValue('book1');

        $productType1 = new ProductType();
        $productType1->setType(ProductDimensionType::PRODUCT_TYPE_L1);
        $productType1->setValue('Media');

        $productType2 = new ProductType();
        $productType2->setType(ProductDimensionType::PRODUCT_TYPE_L2);
        $productType2->setValue('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 = new ProductBiddingCategory();
        $productBiddingCategory->setType(ProductDimensionType::BIDDING_CATEGORY_L1);
        $productBiddingCategory->setValue(-5914235892932915235);

        $productScope->setDimensions(
            [
                $productBrand,
                $productCanonicalCondition,
                $productCustomAttribute,
                $productOfferId,
                $productType1,
                $productType2,
                $productBiddingCategory
            ]
        );

        $campaignCriterion = new CampaignCriterion();
        $campaignCriterion->setCampaignId($campaignId);
        $campaignCriterion->setCriterion($productScope);

        // Create a campaign criterion operation and add it to the operations list.
        $operations = [];
        $operation = new CampaignCriterionOperation();
        $operation->setOperand($campaignCriterion);
        $operation->setOperator(Operator::ADD);
        $operations[] = $operation;

        // Create the campaign criterion on the server and print out some
        // information.
        $campaignCriterionService->mutate($operations);
        printf(
            "Created a ProductScope criterion with ID %d.\n",
            $campaignCriterion->getCriterion()->getId()
        );
    }

    public static function main()
    {
        // Generate a refreshable OAuth2 credential for authentication.
        $oAuth2Credential = (new OAuth2TokenBuilder())->fromFile()->build();

        // Construct an API session configured from a properties file and the
        // OAuth2 credentials above.
        $session = (new AdWordsSessionBuilder())->fromFile()->withOAuth2Credential($oAuth2Credential)->build();
        self::runExample(
            new AdWordsServices(),
            $session,
            intval(self::CAMPAIGN_ID)
        );
    }
}

AddProductScope::main();

Add a Shopping campaign

<?php
/**
 * 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.
 */

namespace Google\AdsApi\Examples\AdWords\v201809\ShoppingCampaigns;

require __DIR__ . '/../../../../vendor/autoload.php';

use Google\AdsApi\AdWords\AdWordsServices;
use Google\AdsApi\AdWords\AdWordsSession;
use Google\AdsApi\AdWords\AdWordsSessionBuilder;
use Google\AdsApi\AdWords\v201809\cm\AdGroup;
use Google\AdsApi\AdWords\v201809\cm\AdGroupAd;
use Google\AdsApi\AdWords\v201809\cm\AdGroupAdOperation;
use Google\AdsApi\AdWords\v201809\cm\AdGroupAdService;
use Google\AdsApi\AdWords\v201809\cm\AdGroupCriterionOperation;
use Google\AdsApi\AdWords\v201809\cm\AdGroupCriterionService;
use Google\AdsApi\AdWords\v201809\cm\AdGroupOperation;
use Google\AdsApi\AdWords\v201809\cm\AdGroupService;
use Google\AdsApi\AdWords\v201809\cm\AdvertisingChannelType;
use Google\AdsApi\AdWords\v201809\cm\BiddableAdGroupCriterion;
use Google\AdsApi\AdWords\v201809\cm\BiddingStrategyConfiguration;
use Google\AdsApi\AdWords\v201809\cm\BiddingStrategyType;
use Google\AdsApi\AdWords\v201809\cm\Budget;
use Google\AdsApi\AdWords\v201809\cm\Campaign;
use Google\AdsApi\AdWords\v201809\cm\CampaignOperation;
use Google\AdsApi\AdWords\v201809\cm\CampaignService;
use Google\AdsApi\AdWords\v201809\cm\CampaignStatus;
use Google\AdsApi\AdWords\v201809\cm\CpcBid;
use Google\AdsApi\AdWords\v201809\cm\Money;
use Google\AdsApi\AdWords\v201809\cm\Operator;
use Google\AdsApi\AdWords\v201809\cm\ProductAd;
use Google\AdsApi\AdWords\v201809\cm\ProductPartition;
use Google\AdsApi\AdWords\v201809\cm\ProductPartitionType;
use Google\AdsApi\AdWords\v201809\cm\ShoppingSetting;
use Google\AdsApi\Common\OAuth2TokenBuilder;

/**
 * This example adds a shopping campaign.
 */
class AddShoppingCampaign
{

    const BUDGET_ID = 'INSERT_BUDGET_ID_HERE';
    const MERCHANT_ID = 'INSERT_MERCHANT_ID_HERE';
    // If set to true, a default partition will be created. If running the
    // AddProductPartitionTree.php example right after this example, make sure
    // this stays set to false.
    const SHOULD_CREATE_DEFAULT_PARTITION = false;

    public static function runExample(
        AdWordsServices $adWordsServices,
        AdWordsSession $session,
        $budgetId,
        $merchantId,
        $shouldCreateDefaultPartition
    ) {
        $campaignService = $adWordsServices->get($session, CampaignService::class);
        $adGroupService = $adWordsServices->get($session, AdGroupService::class);
        $adGroupAdService = $adWordsServices->get($session, AdGroupAdService::class);
        $adGroupCriterionService = $adWordsServices->get($session, AdGroupCriterionService::class);

        // Create a campaign with required and optional settings.
        $campaign = new Campaign();
        $campaign->setName('Shopping campaign #' . uniqid());
        // The advertisingChannelType is what makes this a Shopping campaign
        $campaign->setAdvertisingChannelType(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.
        $campaign->setStatus(CampaignStatus::PAUSED);

        // Set portfolio budget (required).
        $campaign->setBudget(new Budget());
        $campaign->getBudget()->setBudgetId($budgetId);

        // Set bidding strategy (required).
        $biddingStrategyConfiguration = new BiddingStrategyConfiguration();
        $biddingStrategyConfiguration->setBiddingStrategyType(
            BiddingStrategyType::MANUAL_CPC
        );

        $campaign->setBiddingStrategyConfiguration($biddingStrategyConfiguration);

        // All Shopping campaigns need a ShoppingSetting.
        $shoppingSetting = new ShoppingSetting();
        $shoppingSetting->setSalesCountry('US');
        $shoppingSetting->setCampaignPriority(0);
        $shoppingSetting->setMerchantId($merchantId);
        // Set to "true" to enable Local Inventory Ads in your campaign.
        $shoppingSetting->setEnableLocal(true);
        $campaign->setSettings([$shoppingSetting]);

        // Create a campaign operation and add it to the operations list.
        $operations = [];
        $operation = new CampaignOperation();
        $operation->setOperand($campaign);
        $operation->setOperator(Operator::ADD);
        $operations[] = $operation;

        // Create the campaign on the server and print out some information.
        $campaign = $campaignService->mutate($operations)->getValue()[0];
        printf(
            "Campaign with name '%s' and ID %d was added.\n",
            $campaign->getName(),
            $campaign->getId()
        );

        // Create ad group.
        $adGroup = new AdGroup();
        $adGroup->setCampaignId($campaign->getId());
        $adGroup->setName('Ad Group #' . uniqid());

        // Create an ad group operation and add it to the operations list.
        $operations = [];
        $operation = new AdGroupOperation();
        $operation->setOperand($adGroup);
        $operation->setOperator(Operator::ADD);
        $operations[] = $operation;

        // Create the ad group on the server and print out some information.
        $adGroup = $adGroupService->mutate($operations)->getValue()[0];
        printf(
            "Ad group with name '%s' and ID %d was added.\n",
            $adGroup->getName(),
            $adGroup->getId()
        );

        // Create product ad.
        $productAd = new ProductAd();

        // Create ad group ad.
        $adGroupAd = new AdGroupAd();
        $adGroupAd->setAdGroupId($adGroup->getId());
        $adGroupAd->setAd($productAd);

        // Create an ad group ad operation and add it to the operations list.
        $operations = [];
        $operation = new AdGroupAdOperation();
        $operation->setOperand($adGroupAd);
        $operation->setOperator(Operator::ADD);
        $operations[] = $operation;

        // Create the ad group ad on the server and print out some information.
        $adGroupAd = $adGroupAdService->mutate($operations)->getValue()[0];
        printf("Product ad with ID %d was added.\n", $adGroupAd->getAd()->getId());

        if ($shouldCreateDefaultPartition) {
            $operation = self::createDefaultPartitionOperation($adGroup->getId(), 500000);
            $adGroupCriterion = $adGroupCriterionService->mutate([$operation])->getValue()[0];
            printf(
                "Ad group criterion with ID %d in ad group with ID %d was added.\n",
                $adGroupCriterion->getCriterion()->getId(),
                $adGroupCriterion->getAdGroupId()
            );
        }
    }

    private static function createDefaultPartitionOperation(
        $adGroupId,
        $bidAmount
    ) {
        // Creates an ad group criterion for 'All products'.
        $productPartition = new ProductPartition();
        $productPartition->setPartitionType(ProductPartitionType::UNIT);
        // Make sure the caseValue is null and the parentCriterionId is null.
        $productPartition->setParentCriterionId(null);
        $productPartition->setCaseValue(null);

        // Creates a biddable ad group criterion.
        $criterion = new BiddableAdGroupCriterion();
        $biddingStrategyConfiguration = new BiddingStrategyConfiguration();
        $cpcBid = new CpcBid();
        $money = new Money();
        $money->setMicroAmount($bidAmount);
        $cpcBid->setBid($money);
        $biddingStrategyConfiguration->setBids([$cpcBid]);

        $criterion->setBiddingStrategyConfiguration($biddingStrategyConfiguration);
        $criterion->setAdGroupId($adGroupId);
        $criterion->setCriterion($productPartition);

        // Creates an ad group criterion operation.
        $operation = new AdGroupCriterionOperation();
        $operation->setOperand($criterion);
        $operation->setOperator(Operator::ADD);

        return $operation;
    }

    public static function main()
    {
        // Generate a refreshable OAuth2 credential for authentication.
        $oAuth2Credential = (new OAuth2TokenBuilder())->fromFile()->build();

        // Construct an API session configured from a properties file and the
        // OAuth2 credentials above.
        $session = (new AdWordsSessionBuilder())->fromFile()->withOAuth2Credential($oAuth2Credential)->build();
        self::runExample(
            new AdWordsServices(),
            $session,
            intval(self::BUDGET_ID),
            intval(self::MERCHANT_ID),
            boolval(self::SHOULD_CREATE_DEFAULT_PARTITION)
        );
    }
}

AddShoppingCampaign::main();

Add a Smart Shopping campaign

<?php
/**
 * 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
 *
 *     https://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.
 */

namespace Google\AdsApi\Examples\AdWords\v201809\ShoppingCampaigns;

require __DIR__ . '/../../../../vendor/autoload.php';

use Google\AdsApi\AdWords\AdWordsServices;
use Google\AdsApi\AdWords\AdWordsSession;
use Google\AdsApi\AdWords\AdWordsSessionBuilder;
use Google\AdsApi\AdWords\v201809\cm\AdGroup;
use Google\AdsApi\AdWords\v201809\cm\AdGroupAd;
use Google\AdsApi\AdWords\v201809\cm\AdGroupAdOperation;
use Google\AdsApi\AdWords\v201809\cm\AdGroupAdService;
use Google\AdsApi\AdWords\v201809\cm\AdGroupCriterionOperation;
use Google\AdsApi\AdWords\v201809\cm\AdGroupCriterionService;
use Google\AdsApi\AdWords\v201809\cm\AdGroupOperation;
use Google\AdsApi\AdWords\v201809\cm\AdGroupService;
use Google\AdsApi\AdWords\v201809\cm\AdGroupType;
use Google\AdsApi\AdWords\v201809\cm\AdvertisingChannelSubType;
use Google\AdsApi\AdWords\v201809\cm\AdvertisingChannelType;
use Google\AdsApi\AdWords\v201809\cm\BiddableAdGroupCriterion;
use Google\AdsApi\AdWords\v201809\cm\BiddingStrategyConfiguration;
use Google\AdsApi\AdWords\v201809\cm\BiddingStrategyType;
use Google\AdsApi\AdWords\v201809\cm\Budget;
use Google\AdsApi\AdWords\v201809\cm\BudgetBudgetDeliveryMethod;
use Google\AdsApi\AdWords\v201809\cm\BudgetOperation;
use Google\AdsApi\AdWords\v201809\cm\BudgetService;
use Google\AdsApi\AdWords\v201809\cm\Campaign;
use Google\AdsApi\AdWords\v201809\cm\CampaignOperation;
use Google\AdsApi\AdWords\v201809\cm\CampaignService;
use Google\AdsApi\AdWords\v201809\cm\CampaignStatus;
use Google\AdsApi\AdWords\v201809\cm\GoalOptimizedShoppingAd;
use Google\AdsApi\AdWords\v201809\cm\Money;
use Google\AdsApi\AdWords\v201809\cm\Operator;
use Google\AdsApi\AdWords\v201809\cm\ProductPartition;
use Google\AdsApi\AdWords\v201809\cm\ProductPartitionType;
use Google\AdsApi\AdWords\v201809\cm\ShoppingSetting;
use Google\AdsApi\Common\OAuth2TokenBuilder;

/**
 * This example adds a Smart Shopping campaign with an ad group, and ad group
 * ad.
 */
class AddSmartShoppingAd
{

    const MERCHANT_ID = 'INSERT_MERCHANT_ID_HERE';

    // If set to true, a default partition will be created.
    // Set it to false if you plan to run the AddProductPartitionTree.php
    // example right after this example.
    const SHOULD_CREATE_DEFAULT_PARTITION = true;

    public static function runExample(
        AdWordsServices $adWordsServices,
        AdWordsSession $session,
        $merchantId,
        $shouldCreateDefaultPartition
    ) {
        $budgetId = self::createBudget($adWordsServices, $session);
        $campaignId = self::createSmartCampaign(
            $adWordsServices,
            $session,
            $budgetId,
            $merchantId
        );
        $adGroupId = self::createSmartShoppingAdGroup(
            $adWordsServices,
            $session,
            $campaignId
        );
        self::createSmartShoppingAd($adWordsServices, $session, $adGroupId);

        if ($shouldCreateDefaultPartition) {
            self::createDefaultPartition(
                $adWordsServices,
                $session,
                $adGroupId
            );
        }
    }

    /**
     * Creates a non-shared budget for a Smart Shopping campaign. Smart Shopping
     * campaigns support only non-shared budgets.
     *
     * @param AdWordsServices $adWordsServices
     * @param AdWordsSession $session
     * @return int the created budget ID
     */
    private static function createBudget(
        AdWordsServices $adWordsServices,
        AdWordsSession $session
    ) {
        $budgetService = $adWordsServices->get($session, BudgetService::class);

        $budget = new Budget();
        $budget->setName('Interplanetary Cruise Budget #' . uniqid());
        $money = new Money();
        // This budget equals 50.00 units of your account's currency, e.g.,
        // 50 USD if your currency is USD.
        $money->setMicroAmount(50000000);
        $budget->setAmount($money);
        $budget->setDeliveryMethod(BudgetBudgetDeliveryMethod::STANDARD);
        // Non-shared budgets are required for Smart Shopping campaigns.
        $budget->setIsExplicitlyShared(false);

        // Create a budget operation.
        $operation = new BudgetOperation();
        $operation->setOperand($budget);
        $operation->setOperator(Operator::ADD);

        // Create the budget on the server.
        $addedBudget = $budgetService->mutate([$operation])->getValue()[0];

        printf(
            "Budget with name '%s' and ID %d was created.%s",
            $addedBudget->getName(),
            $addedBudget->getBudgetId(),
            PHP_EOL
        );

        return $addedBudget->getBudgetId();
    }

    /**
     * Creates a Smart Shopping campaign.
     *
     * @param AdWordsServices $adWordsServices the AdWords services
     * @param AdWordsSession $session the AdWords session
     * @param int $budgetId the budget ID
     * @param int $merchantId the Merchant center ID
     * @return int the created campaign ID
     */
    private static function createSmartCampaign(
        AdWordsServices $adWordsServices,
        AdWordsSession $session,
        $budgetId,
        $merchantId
    ) {
        $campaignService =
            $adWordsServices->get($session, CampaignService::class);

        // Create a campaign with required and optional settings.
        $campaign = new Campaign();
        $campaign->setName('Smart Shopping campaign #' . uniqid());
        // The advertisingChannelType is what makes this a Shopping campaign.
        $campaign->setAdvertisingChannelType(AdvertisingChannelType::SHOPPING);
        // Sets the advertisingChannelSubType to SHOPPING_GOAL_OPTIMIZED_ADS to
        // make this a Smart Shopping campaign.
        $campaign->setAdvertisingChannelSubType(
            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.
        $campaign->setStatus(CampaignStatus::PAUSED);

        // Set a budget.
        $budget = new Budget();
        $budget->setBudgetId($budgetId);
        $campaign->setBudget($budget);

        // Set a bidding strategy. Only MAXIMIZE_CONVERSION_VALUE is supported.
        $biddingStrategyConfiguration = new BiddingStrategyConfiguration();
        $biddingStrategyConfiguration->setBiddingStrategyType(
            BiddingStrategyType::MAXIMIZE_CONVERSION_VALUE
        );

        $campaign->setBiddingStrategyConfiguration(
            $biddingStrategyConfiguration
        );

        // All Shopping campaigns need a ShoppingSetting.
        $shoppingSetting = new ShoppingSetting();
        $shoppingSetting->setSalesCountry('US');
        $shoppingSetting->setMerchantId($merchantId);
        $campaign->setSettings([$shoppingSetting]);

        // Create a campaign operation and add it to the operations list.
        $operation = new CampaignOperation();
        $operation->setOperand($campaign);
        $operation->setOperator(Operator::ADD);

        // Create the campaign on the server and print out some information.
        $addedCampaign = $campaignService->mutate([$operation])->getValue()[0];
        printf(
            "Smart Shopping campaign with name '%s' and ID %d was added.%s",
            $addedCampaign->getName(),
            $addedCampaign->getId(),
            PHP_EOL
        );

        return $addedCampaign->getId();
    }

    /**
     * Creates a Smart Shopping ad group by setting the ad group type to
     * SHOPPING_GOAL_OPTIMIZED_ADS.
     *
     * @param AdWordsServices $adWordsServices the AdWords services
     * @param AdWordsSession $session the AdWords session
     * @param int $campaignId the campaign ID
     * @return int the ad group ID
     */
    private static function createSmartShoppingAdGroup(
        AdWordsServices $adWordsServices,
        AdWordsSession $session,
        $campaignId
    ) {
        $adGroupService =
            $adWordsServices->get($session, AdGroupService::class);

        // Create an ad group.
        $adGroup = new AdGroup();
        $adGroup->setCampaignId($campaignId);
        $adGroup->setName('Smart Shopping ad group #' . uniqid());

        // Set the ad group type to SHOPPING_GOAL_OPTIMIZED_ADS.
        $adGroup->setAdGroupType(AdGroupType::SHOPPING_GOAL_OPTIMIZED_ADS);

        // Create operation.
        $adGroupOperation = new AdGroupOperation();
        $adGroupOperation->setOperand($adGroup);
        $adGroupOperation->setOperator(Operator::ADD);

        // Create the ad group on the server and print out some information.
        $addedAdGroup = $adGroupService->mutate([$adGroupOperation])
            ->getValue()[0];
        printf(
            "Smart Shopping ad group with name '%s' and ID %d was added.%s",
            $addedAdGroup->getName(),
            $addedAdGroup->getId(),
            PHP_EOL
        );

        return $addedAdGroup->getId();
    }

    /**
     * Creates a Smart Shopping ad.
     *
     * @param AdWordsServices $adWordsServices the AdWords services
     * @param AdWordsSession $session the AdWords session
     * @param int $adGroupId the ad group ID
     */
    private static function createSmartShoppingAd(
        AdWordsServices $adWordsServices,
        AdWordsSession $session,
        $adGroupId
    ) {
        $adGroupAdService =
            $adWordsServices->get($session, AdGroupAdService::class);

        // Create a Smart Shopping ad (Goal-optimized Shopping ad).
        $smartShoppingAd = new GoalOptimizedShoppingAd();

        // Create an ad group ad.
        $adGroupAd = new AdGroupAd();
        $adGroupAd->setAdGroupId($adGroupId);
        $adGroupAd->setAd($smartShoppingAd);

        // Create an ad group ad operation and add it to the operations list.
        $operation = new AdGroupAdOperation();
        $operation->setOperand($adGroupAd);
        $operation->setOperator(Operator::ADD);

        // Create the ad group ad on the server and print out some information.
        $addedAdGroupAd = $adGroupAdService->mutate([$operation])
            ->getValue()[0];
        printf(
            "Smart Shopping ad with ID %d was added.%s",
            $addedAdGroupAd->getAd()->getId(),
            PHP_EOL
        );
    }

    /**
     * Creates a default product partition as an ad group criterion.
     *
     * @param AdWordsServices $adWordsServices the AdWords services
     * @param AdWordsSession $session the AdWords session
     * @param int $adGroupId the ad group ID
     */
    private static function createDefaultPartition(
        AdWordsServices $adWordsServices,
        AdWordsSession $session,
        $adGroupId
    ) {
        $adGroupCriterionService =
            $adWordsServices->get($session, AdGroupCriterionService::class);

        // Creates an ad group criterion for 'All products'.
        $productPartition = new ProductPartition();
        $productPartition->setPartitionType(ProductPartitionType::UNIT);

        // Creates a biddable ad group criterion.
        $criterion = new BiddableAdGroupCriterion();
        $criterion->setAdGroupId($adGroupId);
        $criterion->setCriterion($productPartition);

        // Creates an ad group criterion operation.
        $operation = new AdGroupCriterionOperation();
        $operation->setOperand($criterion);
        $operation->setOperator(Operator::ADD);

        $addedAdGroupCriterion = $adGroupCriterionService->mutate([$operation])
            ->getValue()[0];
        printf(
            "Ad group criterion with ID %d in ad group with ID %d"
            . " was added.%s",
            $addedAdGroupCriterion->getCriterion()->getId(),
            $addedAdGroupCriterion->getAdGroupId(),
            PHP_EOL
        );
    }

    public static function main()
    {
        // Generate a refreshable OAuth2 credential for authentication.
        $oAuth2Credential = (new OAuth2TokenBuilder())->fromFile()->build();

        // Construct an API session configured from a properties file and the
        // OAuth2 credentials above.
        $session = (new AdWordsSessionBuilder())->fromFile()
            ->withOAuth2Credential($oAuth2Credential)
            ->build();
        self::runExample(
            new AdWordsServices(),
            $session,
            intval(self::MERCHANT_ID),
            boolval(self::SHOULD_CREATE_DEFAULT_PARTITION)
        );
    }
}

AddSmartShoppingAd::main();

Get the set of product bidding categories

<?php
/**
 * 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.
 */

namespace Google\AdsApi\Examples\AdWords\v201809\ShoppingCampaigns;

require __DIR__ . '/../../../../vendor/autoload.php';

use Google\AdsApi\AdWords\AdWordsServices;
use Google\AdsApi\AdWords\AdWordsSession;
use Google\AdsApi\AdWords\AdWordsSessionBuilder;
use Google\AdsApi\AdWords\v201809\cm\ConstantDataService;
use Google\AdsApi\AdWords\v201809\cm\Predicate;
use Google\AdsApi\AdWords\v201809\cm\PredicateOperator;
use Google\AdsApi\AdWords\v201809\cm\Selector;
use Google\AdsApi\Common\OAuth2TokenBuilder;

/**
 * This example fetches the set of valid `ProductBiddingCategory`.
 */
class GetProductCategoryTaxonomy
{

    public static function runExample(
        AdWordsServices $adWordsServices,
        AdWordsSession $session
    ) {
        $constantDataService = $adWordsServices->get($session, ConstantDataService::class);

        // Create a selector to select product bidding categories in US.
        $selector = new Selector();
        $selector->setPredicates(
            [new Predicate('Country', PredicateOperator::IN, ['US'])]
        );

        // A mapping from ID to bidding category.
        $biddingCategories = [];
        // An array of root bidding categories (those that don't have any parents).
        $rootCategories = [];

        $productBiddingCategories = $constantDataService->getProductBiddingCategoryData($selector);
        foreach ($productBiddingCategories as $productBiddingCategory) {
            $id = $productBiddingCategory->getDimensionValue()->getvalue();
            $name = $productBiddingCategory->getDisplayValue()[0]->getvalue();
            $parentId = ($productBiddingCategory->getParentDimensionValue() !== null)
                ? $productBiddingCategory->getParentDimensionValue()->getvalue() : null;

            if (array_key_exists($id, $biddingCategories) === false) {
                $biddingCategories[$id] = [
                    'children' => []
                ];
            }
            $biddingCategories[$id]['id'] = $id;
            $biddingCategories[$id]['name'] = $name;

            if ($parentId !== null) {
                if (array_key_exists($parentId, $biddingCategories) === false) {
                    // 'id' and 'name' of $biddingCategories[$parentId] will get
                    // populated in its iteration of this loop.
                    $biddingCategories[$parentId] = [
                        'children' => []
                    ];
                }
                $biddingCategories[$parentId]['children'][] = $biddingCategories[$id];
            } else {
                $rootCategories[] = $biddingCategories[$id];
            }
        }

        self::displayCategories($rootCategories, '');
    }

    private static function displayCategories(array $categories, $prefix)
    {
        foreach ($categories as $category) {
            printf("%s%s [%s]\n", $prefix, $category['name'], $category['id']);
            if (count($category['children']) > 0) {
                self::displayCategories(
                    $category['children'],
                    sprintf('%s%s > ', $prefix, $category['name'])
                );
            }
        }
    }

    public static function main()
    {
        // Generate a refreshable OAuth2 credential for authentication.
        $oAuth2Credential = (new OAuth2TokenBuilder())->fromFile()->build();

        // Construct an API session configured from a properties file and the
        // OAuth2 credentials above.
        $session = (new AdWordsSessionBuilder())->fromFile()->withOAuth2Credential($oAuth2Credential)->build();
        self::runExample(new AdWordsServices(), $session);
    }
}

GetProductCategoryTaxonomy::main();