Campanhas do Shopping

Uma Campanha do Shopping é um tipo de campanha que ajuda a promover seus produtos fornecendo informações de produto detalhadas aos usuários antes mesmo de eles clicarem no seu anúncio. Os anúncios das Campanhas do Shopping exibem uma foto dos seus produtos aos usuários, juntamente com um título, um preço, o nome da loja e outras informações.

Este guia explica como configurar e gerenciar Campanhas do Shopping na AdWords API.

Como vincular as contas do Merchant Center e do Google AdWords

Para criar uma Campanha do Shopping, primeiro você precisa vincular sua conta do Google AdWords à sua conta do Google Merchant Center. Isso requer duas etapas:

  1. Enviar um convite da sua conta do Merchant Center para a sua conta do Google AdWords.
  2. Aceitar o convite na conta do Google AdWords.

Enviar um convite da sua conta do Google Merchant Center

Você pode usar a interface do usuário do Merchant Center para enviar esse convite ou a Content API for Shopping para atualizar o adwordsLinks da sua conta.

Como gerenciar convites na conta do Google AdWords

Você pode usar getServiceLinks e mutateServiceLinks do CustomerService para recuperar, aceitar e rejeitar vínculos entre sua conta do Google AdWords e outros serviços, incluindo o Merchant Center.

Para recuperar todos os vínculos à sua conta, basta chamar getServiceLinks com um predicado no serviceType = MERCHANT_CENTER da seguinte forma:

Java

// Get the CustomerService.
CustomerServiceInterface customerService =
    adWordsServices.get(session, CustomerServiceInterface.class);

// Create a selector that filters by service type.
Selector selector =
    new SelectorBuilder()
        .fields("ServiceType")
        .equals("ServiceType", ServiceType.MERCHANT_CENTER.getValue())
        .build();

// Get the service links.
ServiceLink[] serviceLinks = customerService.getServiceLinks(selector);

// Display the results.
if (serviceLinks != null) {
  for (ServiceLink serviceLink : serviceLinks) {
    System.out.printf(
        "Found service link with service link ID %d, type %s, name '%s', and status %s.%n",
        serviceLink.getServiceLinkId(),
        serviceLink.getServiceType(),
        serviceLink.getName(),
        serviceLink.getLinkStatus());
  }
} else {
  System.out.println("No service links found.");
}

CSharp

// Get the CustomerService.
CustomerService customerService =
    (CustomerService) user.GetService(AdWordsService.v201802.CustomerService);

// Create a selector that filters by service type.
Selector selector = new Selector() {
  fields = new string[] { ServiceLink.Fields.ServiceType },
  predicates = new Predicate[] {
    Predicate.Equals(ServiceLink.Fields.ServiceType, ServiceType.MERCHANT_CENTER.ToString())
  }
};

// Get the service links.
ServiceLink[] serviceLinks = customerService.getServiceLinks(selector);

// Display the results.
if (serviceLinks != null) {
  foreach (ServiceLink serviceLink in serviceLinks) {
    Console.WriteLine("Found service link with service link ID {0}, type {1}, name " +
        "'{2}', and status {3}.", serviceLink.serviceLinkId, serviceLink.serviceType,
        serviceLink.name, serviceLink.linkStatus);
  }
} else {
  Console.WriteLine("No service links found.");
}

Python

def main(client):
  # Initialize appropriate service.
  customer_service = client.GetService('CustomerService',
                                       version='v201802')

  selector = {
      'fields': ['ServiceType'],
      'predicates': [
          {
              'field': 'ServiceType',
              'operator': 'EQUALS',
              'values': ['MERCHANT_CENTER']
          }
      ]
  }

  service_links = customer_service.getServiceLinks(selector)

  # Display results.
  if service_links:
    for service_link in service_links:
      print ('Service link with service link ID \'%s\', type \'%s\', '
             'name \'%s\', and status \'%s\' was found.' %
             (service_link['serviceLinkId'],
              service_link['serviceType'],
              service_link['name'],
              service_link['linkStatus']))
  else:
    print 'No service links were found.'

if __name__ == '__main__':
  # Initialize client object.
  adwords_client = adwords.AdWordsClient.LoadFromStorage()
  main(adwords_client)

PHP

$customerService =
    $adWordsServices->get($session, CustomerService::class);

// Create a selector to select all service links.
$selector = new Selector();
$selector->setFields(['ServiceType']);
$selector->setPredicates(
    [
        new Predicate(
            'ServiceType',
            PredicateOperator::EQUALS,
            [ServiceType::MERCHANT_CENTER]
        )
    ]
);

// Get the service links on the server.
$serviceLinks = $customerService->getServiceLinks($selector);

// Print out some information about service links.
if ($serviceLinks !== null) {
    foreach ($serviceLinks as $serviceLink) {
        printf(
            "Found service link with service link ID %d, type %s, name '%s',"
            . " and status %s.\n",
            $serviceLink->getServiceLinkId(),
            $serviceLink->getServiceType(),
            $serviceLink->getName(),
            $serviceLink->getLinkStatus()
        );
    }
} else {
    print "No service links found.\n";
}

Perl

my $client = shift;

# Create a selector that filters by service type.
my $paging = Google::Ads::AdWords::v201802::Paging->new({
  startIndex    => 0,
  numberResults => PAGE_SIZE
});
my $selector = Google::Ads::AdWords::v201802::Selector->new({
    fields     => ["ServiceType"],
    predicates => [
      Google::Ads::AdWords::v201802::Predicate->new({
          field    => "ServiceType",
          operator => "EQUALS",
          values   => ["MERCHANT_CENTER"]})
    ],
    paging => $paging
  });

# Get the service links.
my $service_links =
  $client->CustomerService->getServiceLinks({selector => $selector});

# Display the results.
if ($service_links) {
  foreach my $service_link ($service_links) {
    printf(
      "Found service link with service link ID %d," .
        " type %s, name '%s', and status %s.\n",
      $service_link->get_serviceLinkId(), $service_link->get_serviceType(),
      $service_link->get_name(),          $service_link->get_linkStatus());

  }
} else {
  printf("No service links found.\n");
}

Ruby

# Get the CustomerService.
customer_srv = adwords.service(:CustomerService, API_VERSION)

# Create a selector that filters by service type.
selector = {
  :fields => ['ServiceType'],
  :predicates => [{
    :field => 'ServiceType',
    :operator => 'EQUALS',
    :values => ['MERCHANT_CENTER']
  }]
}

# Get the service links.
service_links = customer_srv.get_service_links(selector)

# Display the results.
if service_links.kind_of?(Array)
  service_links.each do |service_link|
    puts ("Found service link with service link ID %d, type %s, name '%s'," +
        " and status %s.") % [
          service_link[:service_link_id],
          service_link[:service_type],
          service_link[:name],
          service_link[:link_status]
        ]
  end
else
  puts "No service links found."
end

Para aceitar um convite, chame mutateServiceLinks e passe uma operação SET que altere o linkStatus de PENDING para ACTIVE. Defina o serviceType e o serviceLinkId no operador.

Java

// Get the CustomerService.
CustomerServiceInterface customerService =
    adWordsServices.get(session, CustomerServiceInterface.class);

// Create the operation to set the status to ACTIVE.
ServiceLinkOperation op = new ServiceLinkOperation();
op.setOperator(Operator.SET);
ServiceLink serviceLink = new ServiceLink();
serviceLink.setServiceLinkId(serviceLinkId);
serviceLink.setServiceType(ServiceType.MERCHANT_CENTER);
serviceLink.setLinkStatus(ServiceLinkLinkStatus.ACTIVE);
op.setOperand(serviceLink);

// Update the service link.
ServiceLink[] mutatedServiceLinks =
    customerService.mutateServiceLinks(new ServiceLinkOperation[] {op});

// Display the results.
for (ServiceLink mutatedServiceLink : mutatedServiceLinks) {
  System.out.printf(
      "Service link with service link ID %d, type '%s' updated to status: %s.%n",
      mutatedServiceLink.getServiceLinkId(),
      mutatedServiceLink.getServiceType(),
      mutatedServiceLink.getLinkStatus());
}

CSharp

using (CustomerService customerService = (CustomerService) user.GetService(
    AdWordsService.v201802.CustomerService)) {

  // Create the operation to set the status to ACTIVE.
  ServiceLinkOperation op = new ServiceLinkOperation();
  op.@operator = Operator.SET;
  ServiceLink serviceLink = new ServiceLink();
  serviceLink.serviceLinkId = serviceLinkId;
  serviceLink.serviceType = ServiceType.MERCHANT_CENTER;
  serviceLink.linkStatus = ServiceLinkLinkStatus.ACTIVE;
  op.operand = serviceLink;

  try {
    // Update the service link.
    ServiceLink[] mutatedServiceLinks =
        customerService.mutateServiceLinks(new ServiceLinkOperation[] { op });

    // Display the results.
    foreach (ServiceLink mutatedServiceLink in mutatedServiceLinks) {
      Console.WriteLine("Service link with service link ID {0}, type '{1}' updated to " +
          "status: {2}.", mutatedServiceLink.serviceLinkId, mutatedServiceLink.serviceType,
          mutatedServiceLink.linkStatus);
    }

Python

def main(client, service_link_id):
  # Initialize appropriate service.
  customer_service = client.GetService(
      'CustomerService', version='v201802')

  # Create the operation to set the status to ACTIVE.
  operations = [{
      'operator': 'SET',
      'operand': {
          'serviceLinkId': service_link_id,
          'serviceType': 'MERCHANT_CENTER',
          'linkStatus': 'ACTIVE',
      }
  }]

  # Update the service link.
  mutated_service_links = customer_service.mutateServiceLinks(operations)

  # Display results.
  for mutated_service_link in mutated_service_links:
    print ('Service link with service link ID "%s", type "%s" was updated '
           'to status: "%s".' % (mutated_service_link['serviceLinkId'],
                                 mutated_service_link['serviceType'],
                                 mutated_service_link['linkStatus']))

PHP

$customerService = $adWordsServices->get($session, CustomerService::class);

// Create service link.
$serviceLink = new ServiceLink();
$serviceLink->setServiceLinkId($serviceLinkId);
$serviceLink->setServiceType(ServiceType::MERCHANT_CENTER);
$serviceLink->setLinkStatus(ServiceLinkLinkStatus::ACTIVE);

// Create a service link operation and add it to the list.
$operations = [];
$operation = new ServiceLinkOperation();
$operation->setOperator(Operator::SET);
$operation->setOperand($serviceLink);
$operations[] = $operation;

// Accept service links on the server and print out some information about
// accepted service links.
$serviceLinks = $customerService->mutateServiceLinks($operations);
foreach ($serviceLinks as $serviceLink) {
    printf(
        "Service link with service link ID %d and type '%s' updated to status: %s.\n",
        $serviceLink->getServiceLinkId(),
        $serviceLink->getServiceType(),
        $serviceLink->getLinkStatus()
    );
}

Perl

my $client          = shift;
my $service_link_id = shift;

my $service_link = Google::Ads::AdWords::v201802::ServiceLink->new({
  serviceLinkId => $service_link_id,
  serviceType   => "MERCHANT_CENTER",
  linkStatus    => "ACTIVE"
});

# Create the operation to set the status to ACTIVE.
my $op = Google::Ads::AdWords::v201802::ServiceLinkOperation->new({
  operator => "SET",
  operand  => $service_link
});

# Update the service link.
my $mutated_service_links =
  $client->CustomerService->mutateServiceLinks({operations => [$op]});

# Display the results.
foreach my $mutated_service_link ($mutated_service_links) {
  printf(
    "Service link with service link ID %d, " .
      "type '%s' updated to status: %s.\n",
    $mutated_service_link->get_serviceLinkId(),
    $mutated_service_link->get_serviceType(),
    $mutated_service_link->get_linkStatus());

}

Ruby

# Get the CustomerService.
customer_srv = adwords.service(:CustomerService, API_VERSION)

# Create the operation to set the status to ACTIVE.
operation = {
  :operator => 'SET',
  :operand => {
    :service_link_id => service_link_id,
    :service_type => 'MERCHANT_CENTER',
    :link_status => 'ACTIVE'
  }
}

# Update the service link.
mutated_service_links = customer_srv.mutate_service_links([operation])

# Display the results.
mutated_service_links.each do |mutated_service_link|
  puts ("Service link with service link ID %d, type '%s' updated to status:" +
      "%s.") % [
        mutated_service_link[:service_link_id],
        mutated_service_link[:service_type],
        mutated_service_link[:link_status]
      ]
end

VB.NET

Using customerService As CustomerService = CType(user.GetService(
    AdWordsService.v201802.CustomerService), CustomerService)

  ' Create the operation to set the status to ACTIVE.
  Dim op As New ServiceLinkOperation()
  op.operator = [Operator].SET
  Dim serviceLink As New ServiceLink()
  serviceLink.serviceLinkId = serviceLinkId
  serviceLink.serviceType = ServiceType.MERCHANT_CENTER
  serviceLink.linkStatus = ServiceLinkLinkStatus.ACTIVE
  op.operand = serviceLink

  Try
    ' Update the service link.
    Dim mutatedServiceLinks As ServiceLink() =
      customerService.mutateServiceLinks(New ServiceLinkOperation() {op})

    ' Display the results.
    For Each mutatedServiceLink As ServiceLink In mutatedServiceLinks
      Console.WriteLine("Service link with service link ID {0}, type '{1}' updated to " &
        "status: {2}.", mutatedServiceLink.serviceLinkId, mutatedServiceLink.serviceType,
        mutatedServiceLink.linkStatus)
    Next

Para rejeitar um convite, chame mutateServiceLinks e passe uma operação REMOVE com um operando que tenha serviceType e serviceLinkId definidos.

Java

// Get the CustomerService.
CustomerServiceInterface customerService =
    adWordsServices.get(session, CustomerServiceInterface.class);

// Create the operation to remove the service link.
ServiceLinkOperation op = new ServiceLinkOperation();
op.setOperator(Operator.REMOVE);
ServiceLink serviceLink = new ServiceLink();
serviceLink.setServiceLinkId(serviceLinkId);
serviceLink.setServiceType(ServiceType.MERCHANT_CENTER);
op.setOperand(serviceLink);

// Remove the service link.
ServiceLink[] mutatedServiceLinks =
    customerService.mutateServiceLinks(new ServiceLinkOperation[] {op});

// Display the results.
for (ServiceLink mutatedServiceLink : mutatedServiceLinks) {
  System.out.printf(
      "Service link with service link ID %d and type '%s' was removed.%n",
      mutatedServiceLink.getServiceLinkId(), mutatedServiceLink.getServiceType());
}

CSharp

// Get the CustomerService.
CustomerService customerService =
    (CustomerService) user.GetService(AdWordsService.v201802.CustomerService);

// Create the operation to remove the service link.
ServiceLinkOperation op = new ServiceLinkOperation();
op.@operator = Operator.REMOVE;
ServiceLink serviceLink = new ServiceLink();
serviceLink.serviceLinkId = serviceLinkId;
serviceLink.serviceType = ServiceType.MERCHANT_CENTER;
op.operand = serviceLink;

// Remove the service link.
ServiceLink[] mutatedServiceLinks = customerService.mutateServiceLinks(
    new ServiceLinkOperation[] { op });

// Display the results.
foreach (ServiceLink mutatedServiceLink in mutatedServiceLinks) {
  Console.WriteLine("Service link with service link ID {0} and type '{1}' was removed.",
      mutatedServiceLink.serviceLinkId, mutatedServiceLink.serviceType);
}

Python

def main(client, service_link_id):
  # Initialize appropriate service.
  customer_service = client.GetService(
      'CustomerService', version='v201802')

  # Create the operation to set the status to ACTIVE.
  operations = [{
      'operator': 'REMOVE',
      'operand': {
          'serviceLinkId': service_link_id,
          'serviceType': 'MERCHANT_CENTER',
      }
  }]

  # Remove the service link.
  mutated_service_links = customer_service.mutateServiceLinks(operations)

  # Display results.
  for mutated_service_link in mutated_service_links:
    print ('Service link with service link ID \'%s\' and type \'%s\' was '
           'removed.' % (mutated_service_link['serviceLinkId'],
                         mutated_service_link['serviceType']))

PHP

$customerService =
    $adWordsServices->get($session, CustomerService::class);

// Create service link.
$serviceLink = new ServiceLink();
$serviceLink->setServiceLinkId($serviceLinkId);
$serviceLink->setServiceType(ServiceType::MERCHANT_CENTER);

// Create a service link operation and add it to the list.
$operations = [];
$operation = new ServiceLinkOperation();
$operation->setOperator(Operator::REMOVE);
$operation->setOperand($serviceLink);
$operations[] = $operation;

// Reject service links on the server and print out some information about
// rejected service links.
$serviceLinks = $customerService->mutateServiceLinks($operations);
foreach ($serviceLinks as $serviceLink) {
    printf(
        "Service link with service link ID %d and type '%s' was removed.\n",
        $serviceLink->getServiceLinkId(),
        $serviceLink->getServiceType()
    );
}

Perl

my $client          = shift;
my $service_link_id = shift;

my $service_link = Google::Ads::AdWords::v201802::ServiceLink->new({
  serviceLinkId => $service_link_id,
  serviceType   => "MERCHANT_CENTER"
});

# Create the operation to remove the service link.
my $op = Google::Ads::AdWords::v201802::ServiceLinkOperation->new({
  operator => "REMOVE",
  operand  => $service_link
});

# Remove the service link.
my $mutated_service_links =
  $client->CustomerService->mutateServiceLinks({operations => [$op]});

# Display the results.
foreach my $mutated_service_link ($mutated_service_links) {
  printf(
    "Service link with service link ID %d and type '%s' was removed.\n",
    $mutated_service_link->get_serviceLinkId(),
    $mutated_service_link->get_serviceType());

}

Ruby

# Get the CustomerService.
customer_srv = adwords.service(:CustomerService, API_VERSION)

# Create the operation to remove the service link.
operation = {
  :operator => 'REMOVE',
  :operand => {
    :service_link_id => service_link_id,
    :service_type => 'MERCHANT_CENTER'
  }
}

# Update the service link.
mutated_service_links = customer_srv.mutate_service_links([operation])

# Display the results.
mutated_service_links.each do |mutated_service_link|
  puts "Service link with service link ID %d, type '%s' was removed." % [
    mutated_service_link[:service_link_id],
    mutated_service_link[:service_type]
  ]
end

Como criar uma campanha do Shopping

Ao criar uma Campanha do Shopping, você define os orçamentos, os lances e as configurações. O tipo mais simples de Campanha do Shopping apresenta um lance para todos os produtos.

Há duas etapas exclusivas para a configuração de uma Campanha do Shopping:

  1. Definir o advertisingChannelType da campanha como SHOPPING.

  2. Criar e adicionar um ShoppingSetting à campanha.

As duas etapas são mostradas no código abaixo.

Java

// Create campaign.
Campaign campaign = new Campaign();
campaign.setName("Shopping campaign #" + System.currentTimeMillis());
// The advertisingChannelType is what makes this a Shopping campaign
campaign.setAdvertisingChannelType(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.
campaign.setStatus(CampaignStatus.PAUSED);

// Set shared budget (required).
Budget budget = new Budget();
budget.setBudgetId(budgetId);
campaign.setBudget(budget);

// Set bidding strategy (required).
BiddingStrategyConfiguration biddingStrategyConfiguration = new BiddingStrategyConfiguration();
biddingStrategyConfiguration.setBiddingStrategyType(BiddingStrategyType.MANUAL_CPC);
campaign.setBiddingStrategyConfiguration(biddingStrategyConfiguration);

// All Shopping campaigns need a ShoppingSetting.
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(new Setting[] {shoppingSetting});

// Create operation.
CampaignOperation campaignOperation = new CampaignOperation();
campaignOperation.setOperand(campaign);
campaignOperation.setOperator(Operator.ADD);

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

// Display result.
campaign = campaignAddResult.getValue(0);

System.out.printf("Campaign with name '%s' and ID %d was added.%n", campaign.getName(),
    campaign.getId());

Python

def main(client, budget_id, merchant_id, create_default_partition):
  campaign_service = client.GetService('CampaignService', version='v201802')
  ad_group_service = client.GetService('AdGroupService', version='v201802')
  ad_group_ad_service = client.GetService('AdGroupAdService', version='v201802')

  # Create campaign
  campaign = {
      'name': 'Shopping campaign #%s' % uuid.uuid4(),
      # The advertisingChannelType is what makes this a shopping campaign
      'advertisingChannelType': 'SHOPPING',
      # Recommendation: Set the campaign to PAUSED when creating it to stop the
      # ads from immediately serving. Set to ENABLED once you've added targeting
      # and the ads are ready to serve.
      'status': 'PAUSED',
      # Set portfolio budget (required)
      'budget': {
          'budgetId': budget_id
      },
      'biddingStrategyConfiguration': {
          'biddingStrategyType': 'MANUAL_CPC'
      },
      'settings': [
          # All shopping campaigns need a ShoppingSetting
          {
              'xsi_type': 'ShoppingSetting',
              'salesCountry': 'US',
              'campaignPriority': '0',
              'merchantId': merchant_id,
              # Set to "True" to enable Local Inventory Ads in your campaign.
              'enableLocal': True
          }
      ]
  }

  campaign_operations = [{
      'operator': 'ADD',
      'operand': campaign
  }]

  result = campaign_service.mutate(campaign_operations)

  for campaign in result['value']:
    print ('Campaign with name "%s" and ID "%s" was added.'
           % (campaign['name'], campaign['id']))

  # Create the AdGroup
  ad_group = {
      'campaignId': campaign['id'],
      'name': 'AdGroup #%s' % uuid.uuid4()
  }

  adgroup_operations = {
      'operator': 'ADD',
      'operand': ad_group
  }

  # Make the mutate request to add the AdGroup to the Shopping Campaign
  ad_group = ad_group_service.mutate(adgroup_operations)['value'][0]
  ad_group_id = ad_group['id']

  print ('AdGroup with name "%s" and ID "%s" was added.'
         % (ad_group['name'], ad_group_id))

  # Create an AdGroup Ad
  adgroup_ad = {
      'adGroupId': ad_group_id,
      # Create ProductAd
      'ad': {
          'xsi_type': 'ProductAd',
          'Ad.Type': 'ProductAd'
      }
  }

  ad_operation = {
      'operator': 'ADD',
      'operand': adgroup_ad
  }

  # Make the mutate request to add the ProductAd to the AdGroup
  ad_result = ad_group_ad_service.mutate([ad_operation])

  for adgroup_ad in ad_result['value']:
    print 'ProductAd with ID "%s" was added.' % adgroup_ad['ad']['id']

  if create_default_partition:
    CreateDefaultPartition(client, ad_group_id)

PHP

// 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()
);

Perl

my $campaign = Google::Ads::AdWords::v201802::Campaign->new({
    name => "Shopping campaign #" . uniqid(),
    # The advertisingChannelType is what makes this a Shopping campaign
    advertisingChannelType => "SHOPPING",
    # Recommendation: Set the campaign to PAUSED when creating it to stop
    # the ads from immediately serving. Set to ENABLED once you've added
    # targeting and the ads are ready to serve.
    status => "PAUSED",
    # Set budget (required)
    budget =>
      Google::Ads::AdWords::v201802::Budget->new({budgetId => $budget_id}),
    # Set bidding strategy (required)
    biddingStrategyConfiguration =>
      Google::Ads::AdWords::v201802::BiddingStrategyConfiguration->new(
      {biddingStrategyType => "MANUAL_CPC"}
      ),
    # Set shopping setting (required)
    settings => [
      # All Shopping campaigns need a ShoppingSetting
      Google::Ads::AdWords::v201802::ShoppingSetting->new({
          salesCountry     => "US",
          campaignPriority => 0,
          merchantId       => $merchant_id,
          # By setting enableLocal to true (1) below, you will enable Local
          # Inventory Ads in your campaign. Set this to false (0) if you want
          # to disable this feature in your campaign.
          enableLocal => 1
        })]});

Ruby

# Create campaign.
campaign = {
  :name => "Shopping campaign #%d" % (Time.new.to_f * 1000).to_i,
  # The advertising_channel_type is what makes this a Shopping campaign.
  :advertising_channel_type => 'SHOPPING',
  # Recommendation: Set the campaign to PAUSED when creating it to stop the
  # ads from immediately serving. Set to ENABLED once you've added
  # targeting and the ads are ready to serve.
  :status => 'PAUSED',
  :budget => {:budget_id => budget_id},
  :bidding_strategy_configuration => {
    :bidding_strategy_type => 'MANUAL_CPC'
  },
  :settings => [
    {
      :xsi_type => 'ShoppingSetting',
      :sales_country => 'US',
      :campaign_priority => 0,
      :merchant_id => merchant_id,
      # Set to "true" to enable Local Inventory Ads in your campaign.
      :enable_local => true
    }
  ]
}
campaign_operation = {:operator => 'ADD', :operand => campaign}

# Make the mutate request.
result = campaign_srv.mutate([campaign_operation])

VB.NET

''' <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 Function CreateCampaign(ByVal user As AdWordsUser, ByVal budgetId As Long,
    ByVal merchantId As Long) As Campaign
  ' Get the required services.
  Dim campaignService As CampaignService = CType(user.GetService(
      AdWordsService.v201802.CampaignService), CampaignService)

  ' Create campaign.
  Dim campaign As New Campaign()
  campaign.name = "Shopping campaign #" & ExampleUtilities.GetRandomString()

  ' The advertisingChannelType is what makes this a Shopping campaign.
  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.
  campaign.status = CampaignStatus.PAUSED

  ' Set shared budget (required).
  campaign.budget = New Budget()
  campaign.budget.budgetId = budgetId

  ' Set bidding strategy (required).
  Dim biddingStrategyConfiguration As New BiddingStrategyConfiguration()
  biddingStrategyConfiguration.biddingStrategyType = BiddingStrategyType.MANUAL_CPC

  campaign.biddingStrategyConfiguration = biddingStrategyConfiguration

  ' All Shopping campaigns need a ShoppingSetting.
  Dim shoppingSetting As New ShoppingSetting()
  shoppingSetting.salesCountry = "US"
  shoppingSetting.campaignPriority = 0
  shoppingSetting.merchantId = merchantId

  ' Enable Local Inventory Ads in your campaign.
  shoppingSetting.enableLocal = True
  campaign.settings = New Setting() {shoppingSetting}

  ' Create operation.
  Dim campaignOperation As New CampaignOperation()
  campaignOperation.operand = campaign
  campaignOperation.operator = [Operator].ADD

  ' Make the mutate request.
  Dim retval As CampaignReturnValue = campaignService.mutate(
      New CampaignOperation() {campaignOperation})

  Return retval.value(0)
End Function

Conforme mostrado no exemplo acima, um ShoppingSetting tem as seguintes propriedades:

merchantId (obrigatório)
O ID da conta do Google Merchant Center ao qual seus produtos pertencem.
salesCountry (obrigatório)
Somente produtos com um país de destino correspondente no Merchant Center será selecionado. Isso não afeta a segmentação de anúncios.
campaignPriority (opcional, padrão: 0)
0, 1 ou 2. Isso determina qual campanha deve ter prioridade quando mais de uma usa o mesmo feed de dados do Merchant Center. A campanha com a prioridade mais alta será selecionada. Se duas campanhas tiverem a mesma prioridade, cada anúncio será abrangido por aquela que define o lance mais alto para o produto.
enableLocal (opcional, padrão: false)
Quando definido como true, esse sinalizador ativa anúncios de inventário local nas suas campanhas do Shopping.
purchasePlatform (opcional, padrão: MERCHANT)
Indica a plataforma na qual um produto do Shopping pode ser comprado se sua conta do Merchant Center estiver ativada para Compras no Google.

Como criar um grupo de anúncios e anúncios do Shopping

Para veicular anúncios para sua campanha do Shopping, crie um AdGroup com pelo menos um anúncio no grupo.

As campanhas do Shopping são compatíveis com dois tipos de grupos de anúncios:

  • SHOPPING_PRODUCT_ADS: esse é o tipo de grupo de anúncios padrão para campanhas do Shopping e veicula anúncios de produtos padrão.
  • SHOPPING_SHOWCASE_ADS: esse tipo de grupo de anúncios é limitado a veicular anúncios de demonstração em resultados do Shopping. Para criar um, você precisa:
    1. definir o campo adGroupType do seu grupo de anúncios como SHOPPING_SHOWCASE_ADS;
    2. definir biddingStrategyType do biddingStrategyConfiguration do seu grupo de anúncios como MANUAL_CPC ou ENHANCED_CPC.

Depois de criar o tipo de grupo de anúncios necessário, conclua a configuração básica da sua campanha adicionando um ProductAd ou um ShowcaseAd ao seu grupo de anúncios.

Em seguida, é necessário decidir quais produtos serão incluídos e qual será o valor do lance para eles.

Particionamento

As campanhas do Shopping são eficientes porque nelas seu inventário de produtos é dividido em várias dimensões, e os grupos de anúncios são tratados individualmente. Considere o diagrama abaixo, em que os produtos foram amplamente divididos como "Eletrônicos" (que são separados por marca), "Brinquedos" e "Outros" (que são separados por estado de novo ou usado)

Crie essa estrutura como uma árvore. Cada nível da árvore representa uma partição.

Cada nó da árvore é uma subdivisão ou uma unidade. Uma subdivisão introduz um novo nível na árvore. Já as unidades são as folhas da árvore. Cada subdivisão tem que ser sempre completamente particionada, por isso ela precisa conter um tipo de unidade que represente Outros. No exemplo, a raiz e os nós Categoria: Eletrônicos e Categoria: (Outros) são subdivisões.

Os nós são objetos da classe ProductPartition, que é uma subclasse da Criterion. Os ProductPartitions são vinculados ao AdGroup com BiddableAdGroupCriterion ou NegativeAdGroupCriterion.

A combinação dos tipos ProductPartition e AdGroupCriterion produz os seguintes efeitos:

Tipo ProductPartition Tipo AdGroupCriterion Efeito
UNIDADE BiddableAdGroupCriterion Um lance para os itens que correspondem a essa folha da árvore.
UNIDADE NegativeAdGroupCriterion Essa combinação indica que você não deseja fazer lances para esta folha específica deste grupo de anúncios, mas que outros grupos de anúncios e campanhas (de prioridade mais baixa) podem fazer isso.

Outras combinações resultam em um erro.

Um ProductPartition também tem um caseValue que pode ser qualquer uma das várias subclasses do tipo ProductDimension. Uma ProductDimension representa os valores associados aos seus produtos, como marca, categoria ou condição. Há uma descrição completa dos tipos de ProductDimension disponíveis na documentação de referência.

Cada filho imediato de uma subdivisão precisa ter um caseValue do mesmo subtipo ProductDimension. Somente o nó raiz não tem um caseValue.

ProductPartition root = new ProductPartition();
root.setPartitionType(ProductPartitionType.SUBDIVISION);
root.setId(-1);

ProductPartition node1 = new ProductPartition();
node1.setPartitionType(ProductPartitionType.UNIT);
node1.setCaseValue(new ProductBrand(null, "Brand A"));
node1.setParentCriterionId(root.getId());

Lembre-se de que cada subdivisão precisa conter um caseValue "vazio" do tipo correto que represente "todos os outros valores".

ProductPartition node2 = new ProductPartition();
node2.setPartitionType(ProductPartitionType.UNIT);
node2.setCaseValue(new ProductBrand());
node2.setParentCriterionId(root.getId());

Códigos temporários

Os critérios só recebem IDs depois que a solicitação de modificação que os cria é processada pelo servidor. No entanto, uma ProductPartition é inválida até que seja concluída. Portanto, sempre que você criar uma subdivisão, precisará também criar pelo menos um dos filhos dela na mesma operação.

Para que você possa definir o parentCriterionId para os nós filhos, use IDs de critério temporário. Eles são identificadores exclusivos por local (e não de modo global) que aplicam somente o contexto de uma única solicitação. É possível usar um "integer" negativo como um ID temporário. No exemplo de código acima, o ID da raiz ProductPartition está definido como -1.

Quando a solicitação é processada, é atribuído um ID global positivo a cada Criterion, como de costume.

Dimensões do produto

Os seguintes tipos de ProductDimension estão disponíveis para as Campanhas do Shopping:

ProductBiddingCategory, ProductCustomAttribute e ProductType são divididos em mais subtipos. Durante a subdivisão por um desses tipos, cada caseValue dessa subdivisão também precisa ser do mesmo subtipo.

ProductBiddingCategory e ProductType são hierárquicos, e os subtipos representam a profundidade na hierarquia. A categoria Mídia é uma BIDDING_CATEGORY_L1. Já Livros é uma BIDDING_CATEGORY_L2 e tem Mídia como categoria mãe. Não é possível subdividir por um caseValue, a menos que a mãe já tenha sido subdividida mais acima na árvore.

Por exemplo, não é possível ter a categoria Livros como um nó direto da raiz. Também não é possível ter Livros diretamente em Eletrônicos, pois Eletrônicos não é mãe de Livros.

ProductCustomAttribute não é hierárquico. Em vez disso, os subtipos CUSTOM_ATTRIBUTE_0 a CUSTOM_ATTRIBUTE_4 são compatíveis com os valores atributo personalizado 0 a atributo personalizado 4 no Merchant Center.

É possível especificar os canais local ou on-line (ou ambos) por meio das dimensões de produto ProductChannel e ProductChannelExclusivity.

Categorias de lance

Os valores do tipo ProductBiddingCategory são IDs fixos. É possível recuperar o conjunto completo de categorias de lances com o método ConstantDataService getProductBiddingCategoryData. É altamente recomendável armazenar os resultados dessa chamada em cache, pois o conjunto de dados é grande e não muda com frequência.

Como modificar as árvores ProductPartition existentes

A árvore precisa permanecer sempre completa. Portanto, qualquer operação de modificação que invalide uma árvore precisa fazer parte da mesma solicitação como uma operação que a corrija novamente. Para serem válidos, todos os nós filhos de uma subdivisão precisam ter um caseValue do mesmo tipo, e cada subdivisão precisa conter um nó "outro".

Se você quiser subdividir ainda mais um nó folha, será necessário remover a unidade existente e substituí-la por uma subdivisão com o mesmo caseValue. Assim, você poderá adicionar seus refinamentos como filhos do novo nó.

A remoção de uma subdivisão faz com que todos os seus filhos também sejam removidos de forma recorrente.

Filtrar por dimensões de produto

É possível adicionar um critério ProductScope para filtrar os produtos de uma campanha. Você pode criar no máximo um ProductScope por campanha. Um ProductScope é um contêiner de um ou mais ProductDimensions que representam um filtro simples de um aspecto de um produto. Por exemplo, se você adicionar um subtipo ProductBrand de ProductDimension e definir o valor dele como Nexus, a campanha será aplicada somente a produtos que tiverem "Nexus" definido como marca no Merchant Center.

ProductScope productScope = new ProductScope();
productScope.setDimensions(new ProductDimension[] {new ProductBrand(null, "Nexus")});

É possível adicionar até sete ProductDimensions a um ProductScope. Para serem incluídos na campanha, os produtos precisam ser compatíveis com todos os ProductDimension.

Restrições de lances

As restrições de lances de um grupo de anúncios do Shopping variam de acordo com o tipo de anúncio: SHOPPING_PRODUCT_ADS ou SHOPPING_SHOWCASE_ADS. A tabela a seguir resume as diferenças.

  SHOPPING_PRODUCT_ADS SHOPPING_SHOWCASE_ADS
Estratégia de faturamento Somente os seguintes tipos são suportados:
  • MANUAL_CPC
  • ENHANCED_CPC
  • TARGET_ROAS
  • TARGET_SPEND
Somente os seguintes tipos são suportados:
  • MANUAL_CPC
  • ENHANCED_CPC
Estratégia de lance no nível do grupo de anúncios Opcional Obrigatório
Lances no nível do nó de partição do produto Obrigatório Não permitido

Relatórios

As campanhas do Shopping apresentam dois novos relatórios, o Relatório de partição de produtos e o Relatório de desempenho do Shopping.

Consulte o guia de relatórios para mais informações.

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.