Objetos, métodos e serviços

Este guia apresenta os métodos e objetos da Google AdWords API usando alguns exemplos de tarefas de gerenciamento de campanhas comuns. Ele também descreve os serviços oferecidos pela API, com links para as páginas de referência correspondentes.

A Google AdWords API destina-se aos usuários avançados do Google AdWords. Se você é iniciante no Google AdWords ou precisa aperfeiçoar os conceitos básicos desse produto, confira as páginas de princípios básicos do Google AdWords.

Escopo e hierarquia de objetos

Toda conta do Google AdWords pode ser visualizada como uma hierarquia de objetos.

Em cada conta, há uma ou mais Campaigns que representam as campanhas de publicidade que você está exibindo.

Cada campanha tem vários AdGroups usados para organizar seus anúncios em conjuntos lógicos.

Cada AdGroup contém vários AdGroupAds e AdGroupCriteria. Um "AdGroupAd" representa um anúncio que você está exibindo. Um "AdGroupCriterion" representa um critério (uma palavra-chave) que define a forma como o anúncio é acionado.

Você pode designar critérios de campanha, que definem regras para toda a campanha sobre a forma como os anúncios são acionados. Também é possível especificar orçamentos e datas para toda a campanha.

Você também pode usar extensões no nível da campanha para incluir mais informações nos seus anúncios, como número de telefone, endereço etc.

Cada objeto no Google AdWords é identificado por um código. Alguns desses códigos são exclusivos em nível global em todas as contas do Google AdWords, enquanto outros são exclusivos apenas dentro de um escopo restrito. Confira abaixo a exclusividade de cada código de objeto no Google AdWords.

Código do objeto Escopo de exclusividade Globalmente exclusivo?
Budget ID Global Sim
Campaign ID Global Sim
AdGroup ID Global Sim
Ad ID Grupo de anúncios Não. O par (AdGroupId, AdId) é exclusivo globalmente.
AdGroupCriterion ID Grupo de anúncios Não. O par (AdGroupId, CriterionId) é exclusivo globalmente.
CampaignCriterion ID Campanha Não. O par (CampaignId, CriterionId) é exclusivo globalmente.
Ad Extensions Campanha Não. O par (CampaignId, AdExtensionId) é exclusivo globalmente.
Feed ID Global Sim
Feed Item ID Global Sim
Feed Attribute ID Feed Não
Feed Mapping ID Global Sim
Label ID Global Sim

Essas regras de código podem ser úteis ao desenvolver um banco de dados local para armazenar seus objetos do Google AdWords.

Se um objeto é derivado de outro, ele também tem um campo Type. Por exemplo, TextAd tem um campo Type para indicar que é derivado do objeto Ad. Se você estiver usando uma linguagem dinâmica, poderá utilizar esse campo para confirmar se um objeto Ad é do tipo TextAd.

Métodos e operações

A Google AdWords API oferece serviços para gerenciar objetos do Google AdWords. Por exemplo, CampaignService gerencia "Campaigns", AdGroupService gerencia "AdGroups", e assim por diante.

Todos esses serviços expõem dois métodos padrão get() e mutate().

Método get()

O método get() é usado para recuperar objetos do Google AdWords. Por exemplo, você pode usar CampaignService.get() para recuperar a lista de campanhas.

Cada método get() usa um selector como entrada e retorna uma page como resultado. A Google AdWords API não retorna todos os campos de um objeto por padrão. É necessário especificar a lista de fields que você quer recuperar ao criar um seletor.

Você pode usar predicates para filtrar seus resultados e ordering para classificá-los, além de dateRange para limitar o período dos resultados recuperados.

Se você estiver recuperando vários objetos, também será necessário especificar a paging. Tentar recuperar diversos objetos sem essa especificação fará com que a Google AdWords API acione um erro SizeLimitError.RESPONSE_SIZE_LIMIT_EXCEEDED.

O snippet de código a seguir, que recupera e exibe todas as campanhas em uma conta, mostra como esses conceitos funcionam.

Java

// Get the CampaignService.
CampaignServiceInterface campaignService =
    adWordsServices.get(session, CampaignServiceInterface.class);

int offset = 0;

// Create selector.
SelectorBuilder builder = new SelectorBuilder();
Selector selector = builder
    .fields(CampaignField.Id, CampaignField.Name)
    .orderAscBy(CampaignField.Name)
    .offset(offset)
    .limit(PAGE_SIZE)
    .build();

CampaignPage page;
do {
  // Get all campaigns.
  page = campaignService.get(selector);

  // Display campaigns.
  if (page.getEntries() != null) {
    for (Campaign campaign : page.getEntries()) {
      System.out.printf("Campaign with name '%s' and ID %d was found.%n", campaign.getName(),
          campaign.getId());
    }
  } else {
    System.out.println("No campaigns were found.");
  }

  offset += PAGE_SIZE;
  selector = builder.increaseOffsetBy(PAGE_SIZE).build();
} while (offset < page.getTotalNumEntries());

C#

using (CampaignService campaignService =
    (CampaignService) user.GetService(AdWordsService.v201802.CampaignService)) {

  // Create the selector.
  Selector selector = new Selector() {
    fields = new string[] {
      Campaign.Fields.Id, Campaign.Fields.Name, Campaign.Fields.Status
    },
    paging = Paging.Default
  };

  CampaignPage page = new CampaignPage();

  try {
    do {
      // Get the campaigns.
      page = campaignService.get(selector);

      // Display the results.
      if (page != null && page.entries != null) {
        int i = selector.paging.startIndex;
        foreach (Campaign campaign in page.entries) {
          Console.WriteLine("{0}) Campaign with id = '{1}', name = '{2}' and " +
              "status = '{3}' was found.", i + 1, campaign.id,
              campaign.name, campaign.status);
          i++;
        }
      }
      selector.paging.IncreaseOffset();
    } while (selector.paging.startIndex < page.totalNumEntries);
    Console.WriteLine("Number of campaigns found: {0}", page.totalNumEntries);
  } catch (Exception e) {
    throw new System.ApplicationException("Failed to retrieve campaigns", e);
  }

Python

# Initialize appropriate service.
campaign_service = client.GetService('CampaignService', version='v201802')

# Construct selector and get all campaigns.
offset = 0
selector = {
    'fields': ['Id', 'Name', 'Status'],
    'paging': {
        'startIndex': str(offset),
        'numberResults': str(PAGE_SIZE)
    }
}

more_pages = True
while more_pages:
  page = campaign_service.get(selector)

  # Display results.
  if 'entries' in page:
    for campaign in page['entries']:
      print ('Campaign with id "%s", name "%s", and status "%s" was '
             'found.' % (campaign['id'], campaign['name'],
                         campaign['status']))
  else:
    print 'No campaigns were found.'
  offset += PAGE_SIZE
  selector['paging']['startIndex'] = str(offset)
  more_pages = offset < int(page['totalNumEntries'])

PHP

$campaignService = $adWordsServices->get($session, CampaignService::class);

// Create selector.
$selector = new Selector();
$selector->setFields(['Id', 'Name']);
$selector->setOrdering([new OrderBy('Name', SortOrder::ASCENDING)]);
$selector->setPaging(new Paging(0, self::PAGE_LIMIT));

$totalNumEntries = 0;
do {
    // Make the get request.
    $page = $campaignService->get($selector);

    // Display results.
    if ($page->getEntries() !== null) {
        $totalNumEntries = $page->getTotalNumEntries();
        foreach ($page->getEntries() as $campaign) {
            printf(
                "Campaign with ID %d and name '%s' was found.\n",
                $campaign->getId(),
                $campaign->getName()
            );
        }
    }

    // Advance the paging index.
    $selector->getPaging()->setStartIndex(
        $selector->getPaging()->getStartIndex() + self::PAGE_LIMIT
    );
} while ($selector->getPaging()->getStartIndex() < $totalNumEntries);

printf("Number of results found: %d\n", $totalNumEntries);

Perl

# Create selector.
my $paging = Google::Ads::AdWords::v201802::Paging->new({
    startIndex    => 0,
    numberResults => PAGE_SIZE
});
my $selector = Google::Ads::AdWords::v201802::Selector->new({
    fields   => ["Id", "Name"],
    ordering => [
      Google::Ads::AdWords::v201802::OrderBy->new({
          field     => "Name",
          sortOrder => "ASCENDING"
        })
    ],
    paging => $paging
  });

# Paginate through results.
# The contents of the subroutine will be executed for each campaign.
Google::Ads::AdWords::Utilities::PageProcessor->new({
    client   => $client,
    service  => $client->CampaignService(),
    selector => $selector
  }
  )->process_entries(
  sub {
    my ($campaign) = @_;
    printf "Campaign with name \"%s\" and id \"%d\" was found.\n",
      $campaign->get_name(), $campaign->get_id();
  });

Ruby

campaign_srv = adwords.service(:CampaignService, API_VERSION)

# Get all the campaigns for this account.
selector = {
  :fields => ['Id', 'Name', 'Status'],
  :ordering => [
    {:field => 'Name', :sort_order => 'ASCENDING'}
  ],
  :paging => {
    :start_index => 0,
    :number_results => PAGE_SIZE
  }
}

# Set initial values.
offset, page = 0, {}

begin
  page = campaign_srv.get(selector)
  if page[:entries]
    page[:entries].each do |campaign|
      puts "Campaign ID %d, name '%s' and status '%s'" %
          [campaign[:id], campaign[:name], campaign[:status]]
    end
    # Increment values to request the next page.
    offset += PAGE_SIZE
    selector[:paging][:start_index] = offset
  end
end while page[:total_num_entries] > offset

if page.include?(:total_num_entries)
  puts "\tTotal number of campaigns found: %d." % [page[:total_num_entries]]
end

VB.NET

Using campaignService As CampaignService = CType(user.GetService(
    AdWordsService.v201802.CampaignService), CampaignService)

  ' Create the selector.
  Dim selector As New Selector
  selector.fields = New String() {
    Campaign.Fields.Id, Campaign.Fields.Name, Campaign.Fields.Status
  }
  selector.paging = Paging.Default

  Dim page As New CampaignPage

  Try
    Do
      ' Get the campaigns.
      page = campaignService.get(selector)

      ' Display the results.
      If ((Not page Is Nothing) AndAlso (Not page.entries Is Nothing)) Then
        Dim i As Integer = selector.paging.startIndex
        For Each campaign As Campaign In page.entries
          Console.WriteLine("{0}) Campaign with id = '{1}', name = '{2}' and status = " &
            "'{3}' was found.", i + 1, campaign.id, campaign.name, campaign.status)
          i += 1
        Next
      End If
      selector.paging.IncreaseOffset()
    Loop While (selector.paging.startIndex < page.totalNumEntries)
    Console.WriteLine("Number of campaigns found: {0}", page.totalNumEntries)
  Catch e As Exception
    Throw New System.ApplicationException("Failed to retrieve campaign(s).", e)
  End Try

Consulte a página de referência sobre campos de seletor para ver os campos de seletor disponíveis para diferentes serviços.

Nossas bibliotecas de cliente incluem amostras de código que usam o método get() em todos os serviços de gerenciamento de campanhas. Veja abaixo exemplos de biblioteca de cliente para serviços de gerenciamento de campanhas de cada linguagem.

Método query()

O método query() é uma alternativa para o método get() que utiliza uma linguagem semelhante à SQL, chamada Linguagem de consulta do Google AdWords (AWQL, na sigla em inglês), em vez de seletores. Normalmente, a codificação da mesma solicitação em AWQL é mais eficiente. O método query() aceita a maioria dos serviços comuns. Lembre-se de que a AWQL não aceita a modificação de dados.

Para ver a eficiência da AWQL, considere o exemplo acima. Em vez de escrever quatro linhas para o seletor, escreva uma string que contenha as mesmas informações.

Java

String query = "SELECT Id, Name, Status ORDER BY Name";

C#

// Create the query.
string query = "SELECT Id, Name, Status ORDER BY Name";

Python

query = (adwords.ServiceQueryBuilder()
         .Select('Id', 'Name', 'Status')
         .Where('Status').EqualTo('ENABLED')
         .OrderBy('Name')
         .Limit(0, PAGE_SIZE)
         .Build())

PHP

$query = (new ServiceQueryBuilder())
    ->select(['Id', 'Name', 'Status'])
    ->orderByAsc('Name')
    ->limit(0, self::PAGE_LIMIT)
    ->build();

Perl

my $query =
  Google::Ads::AdWords::Utilities::ServiceQueryBuilder->new(
  {client => $client})
  ->select(["Id", "Name", "Status"])
  ->order_by("Name")
  ->build();

Ruby

# Get all the campaigns for this account.
query_builder = adwords.service_query_builder do |b|
  b.select('Id', 'Name', 'Status')
  b.order_by_asc('Name')
  b.limit(0, PAGE_SIZE)
end
query = query_builder.build

VB.NET

' Create the query.
Dim query As String = "SELECT Id, Name, Status ORDER BY Name"

Não há uma cláusula FROM. O motivo disso é que o serviço cujo método query() você está usando já determina o local de onde ele é selecionado. A AWQL só aceita a cláusula FROM quando é utilizada para relatórios. Para usar essa string, basta chamar o método "query" do serviço.

Java

CampaignPage page = null;
do {
  String pageQuery = query + String.format(" LIMIT %d, %d", offset, PAGE_SIZE);
  // Get all campaigns.
  page = campaignService.query(pageQuery);

  // Display campaigns.
  if (page.getEntries() != null) {
    for (Campaign campaign : page.getEntries()) {
      System.out.printf("Campaign with name '%s' and ID %d was found.%n", campaign.getName(),
          campaign.getId());
    }
  } else {
    System.out.println("No campaigns were found.");
  }

  offset += PAGE_SIZE;
} while (offset < page.getTotalNumEntries());

C#

int offset = 0;
int pageSize = 500;

CampaignPage page = new CampaignPage();

try {
  do {
    string queryWithPaging = string.Format("{0} LIMIT {1}, {2}", query, offset, pageSize);

    // Get the campaigns.
    page = campaignService.query(queryWithPaging);

    // Display the results.
    if (page != null && page.entries != null) {
      int i = offset;
      foreach (Campaign campaign in page.entries) {
        Console.WriteLine("{0}) Campaign with id = '{1}', name = '{2}' and status = " +
            "'{3}' was found.", i + 1, campaign.id, campaign.name, campaign.status);
        i++;
      }
    }
    offset += pageSize;
  } while (offset < page.totalNumEntries);
  Console.WriteLine("Number of campaigns found: {0}", page.totalNumEntries);
} catch (Exception e) {
  throw new System.ApplicationException("Failed to retrieve campaigns", e);
}

Python

for page in query.Pager(campaign_service):
  # Display results.
  if 'entries' in page:
    for campaign in page['entries']:
      print ('Campaign with id "%s", name "%s", and status "%s" was '
             'found.' % (campaign['id'], campaign['name'],
                         campaign['status']))
  else:
    print 'No campaigns were found.'

PHP

do {

    // Advance the paging offset in subsequent iterations only.
    if (isset($page)) {
        $query->nextPage();
    }

    // Make a request using an AWQL string. This request will return the
    // first page containing up to `self::PAGE_LIMIT` results
    $page = $campaignService->query(sprintf('%s', $query));

    // Display results from second and subsequent pages.
    if ($page->getEntries() !== null) {
        foreach ($page->getEntries() as $campaign) {
            printf(
                "Campaign with ID %d and name '%s' was found.\n",
                $campaign->getId(),
                $campaign->getName()
            );
        }
    }
} while ($query->hasNext($page));

printf("Number of results found: %d\n",
    $page->getTotalNumEntries());

Perl

Google::Ads::AdWords::Utilities::PageProcessor->new({
    client    => $client,
    service   => $client->CampaignService(),
    query     => $query,
    page_size => PAGE_SIZE
  }
  )->process_entries(
  sub {
    my ($campaign) = @_;
    printf "Campaign with name \"%s\" and id \"%d\" was found.\n",
      $campaign->get_name(), $campaign->get_id();
  });

Ruby

loop do
  page_query = query.to_s
  page = campaign_srv.query(page_query)
  if page[:entries]
    page[:entries].each do |campaign|
      puts "Campaign ID %d, name '%s' and status '%s'" %
          [campaign[:id], campaign[:name], campaign[:status]]
    end
  end
  break unless query.has_next(page)
  query.next_page
end

if page.include?(:total_num_entries)
  puts "\tTotal number of campaigns found: %d." % page[:total_num_entries]
end

VB.NET

Dim offset As Long = 0
Dim pageSize As Long = 500

Dim page As New CampaignPage()

Try
  Do
    Dim queryWithPaging As String = String.Format("{0} LIMIT {1}, {2}", query, offset,
        pageSize)

    ' Get the campaigns.
    page = campaignService.query(queryWithPaging)

    ' Display the results.
    If ((Not page Is Nothing) AndAlso (Not page.entries Is Nothing)) Then
      Dim i As Integer = CInt(offset)
      For Each campaign As Campaign In page.entries
        Console.WriteLine("{0}) Campaign with id = '{1}', name = '{2}' and status = " &
            "'{3}' was found.", i, campaign.id, campaign.name, campaign.status)
        i += 1
      Next
    End If
    offset = offset + pageSize
  Loop While (offset < page.totalNumEntries)
  Console.WriteLine("Number of campaigns found: {0}", page.totalNumEntries)
Catch e As Exception
  Throw New System.ApplicationException("Failed to retrieve campaign(s).", e)
End Try

O código acima produz os mesmos resultados de uma chamada para o método get(). A AWQL pode ser uma maneira mais rápida e intuitiva de escrever as mesmas solicitações que você faria com a chamada get(). Para saber mais, consulte o guia sobre a AWQL.

Método mutate()

O método mutate() é usado para modificar (criar, atualizar ou remover) um objeto do Google AdWords.

Para modificar um objeto, você precisa criar uma Operation correspondente. Por exemplo, é preciso criar uma CampaignOperation para modificar uma Campaign.

O campo operator define o tipo de operação que você quer realizar (ADD, SET ou REMOVE). O campo "operando" contém o objeto que você deseja modificar. Veja a seguir como o snippet de código adiciona as campanhas:

Java

// Get the CampaignService.
CampaignServiceInterface campaignService =
    adWordsServices.get(session, CampaignServiceInterface.class);

// Create campaign.
Campaign campaign = new Campaign();
campaign.setName("Interplanetary Cruise #" + System.currentTimeMillis());

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

BiddingStrategyConfiguration biddingStrategyConfiguration = new BiddingStrategyConfiguration();
biddingStrategyConfiguration.setBiddingStrategyType(BiddingStrategyType.MANUAL_CPC);

// You can optionally provide a bidding scheme in place of the type.
ManualCpcBiddingScheme cpcBiddingScheme = new ManualCpcBiddingScheme();
biddingStrategyConfiguration.setBiddingScheme(cpcBiddingScheme);

campaign.setBiddingStrategyConfiguration(biddingStrategyConfiguration);

// You can optionally provide these field(s).
campaign.setStartDate(new DateTime().plusDays(1).toString("yyyyMMdd"));
campaign.setEndDate(new DateTime().plusDays(30).toString("yyyyMMdd"));
campaign.setFrequencyCap(new FrequencyCap(5L, TimeUnit.DAY, Level.ADGROUP));

// Only the budgetId should be sent, all other fields will be ignored by CampaignService.
Budget budget = new Budget();
budget.setBudgetId(budgetId);
campaign.setBudget(budget);

campaign.setAdvertisingChannelType(AdvertisingChannelType.SEARCH);

// Set the campaign network options to Search and Search Network.
NetworkSetting networkSetting = new NetworkSetting();
networkSetting.setTargetGoogleSearch(true);
networkSetting.setTargetSearchNetwork(true);
networkSetting.setTargetContentNetwork(false);
networkSetting.setTargetPartnerSearchNetwork(false);
campaign.setNetworkSetting(networkSetting);

// Set options that are not required.
GeoTargetTypeSetting geoTarget = new GeoTargetTypeSetting();
geoTarget.setPositiveGeoTargetType(GeoTargetTypeSettingPositiveGeoTargetType.DONT_CARE);
campaign.setSettings(new Setting[] {geoTarget});

// You can create multiple campaigns in a single request.
Campaign campaign2 = new Campaign();
campaign2.setName("Interplanetary Cruise banner #" + System.currentTimeMillis());
campaign2.setStatus(CampaignStatus.PAUSED);
BiddingStrategyConfiguration biddingStrategyConfiguration2 = new BiddingStrategyConfiguration();
biddingStrategyConfiguration2.setBiddingStrategyType(BiddingStrategyType.MANUAL_CPC);
campaign2.setBiddingStrategyConfiguration(biddingStrategyConfiguration2);

Budget budget2 = new Budget();
budget2.setBudgetId(budgetId);
campaign2.setBudget(budget2);

campaign2.setAdvertisingChannelType(AdvertisingChannelType.DISPLAY);

// Create operations.
CampaignOperation operation = new CampaignOperation();
operation.setOperand(campaign);
operation.setOperator(Operator.ADD);
CampaignOperation operation2 = new CampaignOperation();
operation2.setOperand(campaign2);
operation2.setOperator(Operator.ADD);

CampaignOperation[] operations = new CampaignOperation[] {operation, operation2};

// Add campaigns.
CampaignReturnValue result = campaignService.mutate(operations);

// Display campaigns.
for (Campaign campaignResult : result.getValue()) {
  System.out.printf("Campaign with name '%s' and ID %d was added.%n", campaignResult.getName(),
      campaignResult.getId());
}

C#

List<CampaignOperation> operations = new List<CampaignOperation>();

for (int i = 0; i < NUM_ITEMS; i++) {
  // Create the campaign.
  Campaign campaign = new Campaign();
  campaign.name = "Interplanetary Cruise #" + ExampleUtilities.GetRandomString();
  campaign.advertisingChannelType = AdvertisingChannelType.SEARCH;

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

  BiddingStrategyConfiguration biddingConfig = new BiddingStrategyConfiguration();
  biddingConfig.biddingStrategyType = BiddingStrategyType.MANUAL_CPC;
  campaign.biddingStrategyConfiguration = biddingConfig;

  campaign.budget = new Budget();
  campaign.budget.budgetId = budget.budgetId;

  // Set the campaign network options.
  campaign.networkSetting = new NetworkSetting();
  campaign.networkSetting.targetGoogleSearch = true;
  campaign.networkSetting.targetSearchNetwork = true;
  campaign.networkSetting.targetContentNetwork = false;
  campaign.networkSetting.targetPartnerSearchNetwork = false;

  // Set the campaign settings for Advanced location options.
  GeoTargetTypeSetting geoSetting = new GeoTargetTypeSetting();
  geoSetting.positiveGeoTargetType = GeoTargetTypeSettingPositiveGeoTargetType.DONT_CARE;
  geoSetting.negativeGeoTargetType = GeoTargetTypeSettingNegativeGeoTargetType.DONT_CARE;

  campaign.settings = new Setting[] { geoSetting };

  // Optional: Set the start date.
  campaign.startDate = DateTime.Now.AddDays(1).ToString("yyyyMMdd");

  // Optional: Set the end date.
  campaign.endDate = DateTime.Now.AddYears(1).ToString("yyyyMMdd");

  // Optional: Set the frequency cap.
  FrequencyCap frequencyCap = new FrequencyCap();
  frequencyCap.impressions = 5;
  frequencyCap.level = Level.ADGROUP;
  frequencyCap.timeUnit = TimeUnit.DAY;
  campaign.frequencyCap = frequencyCap;

  // Create the operation.
  CampaignOperation operation = new CampaignOperation();
  operation.@operator = Operator.ADD;
  operation.operand = campaign;

  operations.Add(operation);
}

try {
  // Add the campaign.
  CampaignReturnValue retVal = campaignService.mutate(operations.ToArray());

  // Display the results.
  if (retVal != null && retVal.value != null && retVal.value.Length > 0) {
    foreach (Campaign newCampaign in retVal.value) {
      Console.WriteLine("Campaign with name = '{0}' and id = '{1}' was added.",
          newCampaign.name, newCampaign.id);
    }
  } else {
    Console.WriteLine("No campaigns were added.");
  }
} catch (Exception e) {
  throw new System.ApplicationException("Failed to add campaigns.", e);
}

Python

operations = [{
    'operator': 'ADD',
    'operand': {
        'name': 'Interplanetary Cruise #%s' % uuid.uuid4(),
        # 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',
        'advertisingChannelType': 'SEARCH',
        'biddingStrategyConfiguration': {
            'biddingStrategyType': 'MANUAL_CPC',
        },
        'endDate': (datetime.datetime.now() +
                    datetime.timedelta(365)).strftime('%Y%m%d'),
        # Note that only the budgetId is required
        'budget': {
            'budgetId': budget_id
        },
        'networkSetting': {
            'targetGoogleSearch': 'true',
            'targetSearchNetwork': 'true',
            'targetContentNetwork': 'false',
            'targetPartnerSearchNetwork': 'false'
        },
        # Optional fields
        'startDate': (datetime.datetime.now() +
                      datetime.timedelta(1)).strftime('%Y%m%d'),
        'frequencyCap': {
            'impressions': '5',
            'timeUnit': 'DAY',
            'level': 'ADGROUP'
        },
        'settings': [
            {
                'xsi_type': 'GeoTargetTypeSetting',
                'positiveGeoTargetType': 'DONT_CARE',
                'negativeGeoTargetType': 'DONT_CARE'
            }
        ]
    }
}, {
    'operator': 'ADD',
    'operand': {
        'name': 'Interplanetary Cruise banner #%s' % uuid.uuid4(),
        'status': 'PAUSED',
        'biddingStrategyConfiguration': {
            'biddingStrategyType': 'MANUAL_CPC'
        },
        'endDate': (datetime.datetime.now() +
                    datetime.timedelta(365)).strftime('%Y%m%d'),
        # Note that only the budgetId is required
        'budget': {
            'budgetId': budget_id
        },
        'advertisingChannelType': 'DISPLAY'
    }
}]
campaigns = campaign_service.mutate(operations)

# Display results.
for campaign in campaigns['value']:
  print ('Campaign with name "%s" and id "%s" was added.'
         % (campaign['name'], campaign['id']))

PHP

$campaignService = $adWordsServices->get($session, CampaignService::class);

$operations = [];

// Create a campaign with required and optional settings.
$campaign = new Campaign();
$campaign->setName('Interplanetary Cruise #' . uniqid());
$campaign->setAdvertisingChannelType(AdvertisingChannelType::SEARCH);

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

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

// You can optionally provide a bidding scheme in place of the type.
$biddingScheme = new ManualCpcBiddingScheme();
$biddingStrategyConfiguration->setBiddingScheme($biddingScheme);

$campaign->setBiddingStrategyConfiguration($biddingStrategyConfiguration);

// Set network targeting (optional).
$networkSetting = new NetworkSetting();
$networkSetting->setTargetGoogleSearch(true);
$networkSetting->setTargetSearchNetwork(true);
$networkSetting->setTargetContentNetwork(true);
$campaign->setNetworkSetting($networkSetting);

// Set additional settings (optional).
// 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);
$campaign->setStartDate(date('Ymd', strtotime('+1 day')));
$campaign->setEndDate(date('Ymd', strtotime('+1 month')));

// Set frequency cap (optional).
$frequencyCap = new FrequencyCap();
$frequencyCap->setImpressions(5);
$frequencyCap->setTimeUnit(TimeUnit::DAY);
$frequencyCap->setLevel(Level::ADGROUP);
$campaign->setFrequencyCap($frequencyCap);

// Set advanced location targeting settings (optional).
$geoTargetTypeSetting = new GeoTargetTypeSetting();
$geoTargetTypeSetting->setPositiveGeoTargetType(
    GeoTargetTypeSettingPositiveGeoTargetType::DONT_CARE
);
$geoTargetTypeSetting->setNegativeGeoTargetType(
    GeoTargetTypeSettingNegativeGeoTargetType::DONT_CARE
);
$campaign->setSettings([$geoTargetTypeSetting]);

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

// Create a campaign with only required settings.
$campaign = new Campaign();
$campaign->setName('Interplanetary Cruise #' . uniqid());
$campaign->setAdvertisingChannelType(AdvertisingChannelType::DISPLAY);

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

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

$campaign->setStatus(CampaignStatus::PAUSED);

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

// Create the campaigns on the server and print out some information for
// each created campaign.
$result = $campaignService->mutate($operations);
foreach ($result->getValue() as $campaign) {
    printf(
        "Campaign with name '%s' and ID %d was added.\n",
        $campaign->getName(),
        $campaign->getId()
    );
}

Perl

# Create campaigns.
my $num_campaigns = 2;
my @operations    = ();
for (my $i = 0 ; $i < $num_campaigns ; $i++) {
  my (undef, undef, undef, $mday, $mon, $year) = localtime(time);
  my $today = sprintf("%d%02d%02d", ($year + 1900), ($mon + 1), $mday);
  (undef, undef, undef, $mday, $mon, $year) = localtime(time + 60 * 60 * 24);
  my $tomorrow = sprintf("%d%02d%02d", ($year + 1900), ($mon + 1), $mday);
  my $campaign = Google::Ads::AdWords::v201802::Campaign->new({
      name => "Interplanetary Cruise #" . uniqid(),
      # Bidding strategy (required).
      biddingStrategyConfiguration =>
        Google::Ads::AdWords::v201802::BiddingStrategyConfiguration->new({
          biddingStrategyType => "MANUAL_CPC",
          # You can optionally provide a bidding scheme in place of the type.
        }
        ),
      # Budget (required) - note only the budgetId is required.
      budget =>
        Google::Ads::AdWords::v201802::Budget->new({budgetId => $budgetId}),
      # Create a Search Network with Display Select campaign.
      # To create a Display Only campaign, omit networkSetting and use the
      # DISPLAY advertisingChannelType.
      # NetworkSetting (optional).
      networkSetting => Google::Ads::AdWords::v201802::NetworkSetting->new({
          targetGoogleSearch         => 1,
          targetSearchNetwork        => 1,
          targetContentNetwork       => 1,
          targetPartnerSearchNetwork => 0
        }
      ),
      # Advertising channel type (required).
      advertisingChannelType => "SEARCH",
      # Frequency cap (non-required).
      frequencyCap => Google::Ads::AdWords::v201802::FrequencyCap->new({
          impressions => 5,
          timeUnit    => "DAY",
          level       => "ADGROUP"
        }
      ),
      settings => [
        # Advanced location targeting settings (non-required).
        Google::Ads::AdWords::v201802::GeoTargetTypeSetting->new({
            positiveGeoTargetType => "DONT_CARE",
            negativeGeoTargetType => "DONT_CARE"
          }
        ),
      ],
      # Additional properties (non-required).
      startDate                   => $today,
      endDate                     => $tomorrow,
      # 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"
    });

  # Create operation.
  my $campaign_operation =
    Google::Ads::AdWords::v201802::CampaignOperation->new({
      operator => "ADD",
      operand  => $campaign
    });
  push @operations, $campaign_operation;
}

# Add campaigns.
my $result = $client->CampaignService()->mutate({operations => \@operations});

# Display campaigns.
foreach my $campaign (@{$result->get_value()}) {
  printf "Campaign with name \"%s\" and id \"%s\" was added.\n",
    $campaign->get_name(), $campaign->get_id();
}

Ruby

campaign_srv = adwords.service(:CampaignService, API_VERSION)

# Create campaigns.
campaigns = [
  {
    :name => "Interplanetary Cruise #%d" % (Time.new.to_f * 1000).to_i,
    # 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',
    :bidding_strategy_configuration => {
      :bidding_strategy_type => 'MANUAL_CPC'
    },
    # Budget (required) - note only the budget ID is required.
    :budget => {:budget_id => budget_id},
    :advertising_channel_type => 'SEARCH',
    # Optional fields:
    :start_date =>
        DateTime.parse((Date.today + 1).to_s).strftime('%Y%m%d'),
    :network_setting => {
      :target_google_search => true,
      :target_search_network => true,
      :target_content_network => true
    },
    :settings => [
      {
        :xsi_type => 'GeoTargetTypeSetting',
        :positive_geo_target_type => 'DONT_CARE',
        :negative_geo_target_type => 'DONT_CARE'
      }
    ],
    :frequency_cap => {
      :impressions => '5',
      :time_unit => 'DAY',
      :level => 'ADGROUP'
    }
  },
  {
    :name => "Interplanetary Cruise banner #%d" % (Time.new.to_f * 1000).to_i,
    :status => 'PAUSED',
    :bidding_strategy_configuration => {
      :bidding_strategy_type => 'MANUAL_CPC'
    },
    :budget => {:budget_id => budget_id},
    :advertising_channel_type => 'DISPLAY'
  }
]

# Prepare for adding campaign.
operations = campaigns.map do |campaign|
  {:operator => 'ADD', :operand => campaign}
end

# Add campaign.
response = campaign_srv.mutate(operations)
if response and response[:value]
  response[:value].each do |campaign|
    puts "Campaign with name '%s' and ID %d was added." %
        [campaign[:name], campaign[:id]]
  end
else
  raise new StandardError, 'No campaigns were added.'
end

VB.NET

  Dim operations As New List(Of CampaignOperation)

  For i As Integer = 1 To NUM_ITEMS
    ' Create the campaign.
    Dim campaign As New Campaign
    campaign.name = "Interplanetary Cruise #" & ExampleUtilities.GetRandomString
    campaign.advertisingChannelType = AdvertisingChannelType.SEARCH

    ' 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

    Dim biddingConfig As New BiddingStrategyConfiguration()
    biddingConfig.biddingStrategyType = BiddingStrategyType.MANUAL_CPC
    campaign.biddingStrategyConfiguration = biddingConfig

    ' Set the campaign budget.
    campaign.budget = New Budget
    campaign.budget.budgetId = budget.budgetId

    ' Set the campaign network options.
    campaign.networkSetting = New NetworkSetting
    campaign.networkSetting.targetGoogleSearch = True
    campaign.networkSetting.targetSearchNetwork = True
    campaign.networkSetting.targetContentNetwork = False
    campaign.networkSetting.targetPartnerSearchNetwork = False

    ' Set the campaign geo target and keyword match settings.
    Dim geoSetting As New GeoTargetTypeSetting
    geoSetting.positiveGeoTargetType = GeoTargetTypeSettingPositiveGeoTargetType.DONT_CARE
    geoSetting.negativeGeoTargetType = GeoTargetTypeSettingNegativeGeoTargetType.DONT_CARE

    campaign.settings = New Setting() {geoSetting}

    ' Optional: Set the start date.
    campaign.startDate = DateTime.Now.AddDays(1).ToString("yyyyMMdd")

    ' Optional: Set the end date.
    campaign.endDate = DateTime.Now.AddYears(1).ToString("yyyyMMdd")

    ' Optional: Set the frequency cap.
    Dim frequencyCap As New FrequencyCap
    frequencyCap.impressions = 5
    frequencyCap.level = Level.ADGROUP
    frequencyCap.timeUnit = TimeUnit.DAY
    campaign.frequencyCap = frequencyCap

    ' Create the operation.
    Dim operation As New CampaignOperation
    operation.operator = [Operator].ADD
    operation.operand = campaign
    operations.Add(operation)
  Next

  Try
    ' Add the campaign.
    Dim retVal As CampaignReturnValue = campaignService.mutate(operations.ToArray())

    ' Display the results.
    If ((Not retVal Is Nothing) AndAlso (Not retVal.value Is Nothing) AndAlso
      (retVal.value.Length > 0)) Then
      For Each newCampaign As Campaign In retVal.value
        Console.WriteLine("Campaign with name = '{0}' and id = '{1}' was added.",
            newCampaign.name, newCampaign.id)
      Next
    Else
      Console.WriteLine("No campaigns were added.")
    End If
  Catch e As Exception
    Throw New System.ApplicationException("Failed to add campaigns.", e)
  End Try
End Using

Nossas bibliotecas de cliente incluem exemplos de código que usam o método mutate() em todos os serviços de gerenciamento de campanhas.

Ao fazer uma modificação, lembre-se de que uma conta do Google AdWords pode incluir um número limitado de objetos de determinado tipo. Os limites para vários tipos de objeto do Google AdWords estão descritos neste artigo da Central de Ajuda. Em vez de codificar esses limites no seu aplicativo, use-os apenas como referência ao planejar suas campanhas.

Ao chamar mutate(), recomendamos que você envie várias operações por solicitação em vez de várias solicitações com uma operação por solicitação. O envio de várias operações por solicitação reduz o número de viagens de ida e volta ao servidor e melhora o desempenho do seu aplicativo.

Outra dica de otimização é agrupar suas solicitações por operações em uma única entidade pai. Por exemplo, ao adicionar anúncios, tente agrupar suas solicitações em um grupo de anúncios em vez de uma solicitação em vários grupos. Consulte o guia de práticas recomendadas para mais informações.

Campo "operador"

Conforme mencionado acima, o campo operator indica o tipo de operação de modificação que você quer realizar: ADD, SET ou REMOVE.

A operação ADD é usada para criar um novo objeto, SET destina-se a atualizar um objeto existente e REMOVE, para remover um objeto existente. No entanto, às vezes alguns operadores não são aplicáveis a determinados serviços.

Por exemplo, uma campanha do Google AdWords não pode ser removida permanentemente depois de criada. Só é possível marcá-la como REMOVED. Mesmo com o status REMOVED, você ainda poderá consultar os detalhes e as estatísticas dela.

A Google AdWords API não aceita o operador REMOVE no "CampaignService". É necessário atualizar a "Campaign" alterando o status dela para REMOVED com o operador SET.

Por outro lado, as segmentações de campanha não podem ser alteradas. Você pode usar apenas ADD ou REMOVE nesses objetos.

A tabela abaixo explica como controlar o fluxo de diferentes objetos do Google AdWords para atingir um status desejado:

Tipo Adicionar novo objeto Ativar Pausar Remover / Desativar
Campaign ação: mutate()
operação: ADD
status: ENABLED
ação: mutate()
operação: SET
status: ENABLED
ação: mutate()
operação: SET
status: PAUSED
ação: mutate()
operação: SET
status: REMOVED
Budget ação: mutate()
operação: ADD
status: ENABLED
N/D N/D ação: mutate()
operação: SET
status: REMOVED
AdGroup ação: mutate()
operação: ADD
status: ENABLED
ação: mutate()
operação: SET
status: ENABLED
ação: mutate()
operação: SET
status: PAUSED
ação: mutate()
operação: SET
status: REMOVED
AdGroupAd ação: mutate()
operação: ADD
status: ENABLED
ação: mutate()
operação: SET
status: ENABLED
ação: mutate()
operação: SET
status: PAUSED
ação: mutate()
operação: REMOVE
status: DISABLED
BiddableAdGroupCriterion ação: mutate()
operação: ADD
status: ENABLED
ação: mutate()
operação: SET
status: ENABLED
ação: mutate()
operação: SET
status: PAUSED
ação: mutate
operação: REMOVE
status: REMOVED
UserList ação: mutate()
operação: ADD
status: OPEN
N/A N/D ação: mutate()
operação: SET
status: CLOSED
Feed ação: mutate()
operação: ADD
status: ENABLED
N/A N/D ação: mutate()
operação: REMOVE
status: REMOVED
FeedMapping ação: mutate()
operação: ADD
status: ENABLED
N/A N/D ação: mutate()
operação: REMOVE
status: REMOVED
FeedItem ação: mutate
operação: ADD
status: ENABLED
N/A N/D ação: mutate()
operação: REMOVE
status: REMOVED
CustomerFeed ação: mutate()
operação: ADD
status: ENABLED
N/A N/D ação: mutate()
operação: REMOVE
status: REMOVED
CampaignFeed ação: mutate()
operação: ADD
status: ENABLED
N/A N/D ação: mutate()
operação: REMOVE
status: REMOVED
AdGroupFeed ação: mutate()
operação: ADD
status: ENABLED
N/A N/D ação: mutate()
operação: REMOVE
status: REMOVED

Modificações simultâneas

Caso muitos usuários estejam atualizando o mesmo objeto com o seu aplicativo ou se você está modificando os objetos do Google AdWords paralelamente por meio de várias conversas para ter um rendimento melhor, é importante entender como o Google AdWords lida com solicitações de modificação simultânea para o mesmo objeto.

Um objeto do Google AdWords não pode ser modificado simultaneamente por mais de uma origem. Isso inclui a atualização do objeto por meio de conversas no mesmo aplicativo ou em outros aplicativos (por exemplo, seu aplicativo e uma sessão simultânea do AdWords Editor). A API não oferece uma maneira de bloquear um objeto antes da atualização. Se duas origens tentarem modificar simultaneamente um objeto, a API acionará um erro CONCURRENT_MODIFICATION_ERROR.

Saiba mais sobre o gerenciamento simultâneo da Google AdWords API nesta postagem do blog.

Modificações síncronas e assíncronas

Os métodos mutate() da Google AdWords API são síncronos, ou seja, as chamadas de API retornam uma resposta somente depois da modificação dos objetos, e você precisa esperar a resposta de cada solicitação. Embora a codificação dessa abordagem seja relativamente simples, ela pode comprometer o balanceamento de carga e desperdiçar recursos enquanto as máquinas aguardam a conclusão de uma chamada.

Uma abordagem alternativa consiste em modificar os objetos de modo assíncrono usando o BatchJobService, que oferece uma maneira de executar lotes de operações em vários serviços sem precisar aguardar a conclusão das operações. Após o envio da tarefa em lote, os servidores da Google AdWords API realizam as operações de modo assíncrono, permitindo que sua máquina realize outras operações e verifique periodicamente o status da tarefa até a conclusão.

Consulte o guia sobre processamento em lote para saber mais sobre o processamento assíncrono.

Validação da modificação

Com o cabeçalho SOAP validateOnly, você pode testar suas chamadas de API com base em dados reais, sem precisar executar a chamada. É possível realizar o teste para saber se há parâmetros ausentes e valores de campo incorretos sem a necessidade de realizar a operação.

Para usar esse recurso, defina o campo validateOnly como true no RequestHeader. Por padrão, as bibliotecas cliente definem esse campo como false.

A solicitação é totalmente validada como se fosse ser realizada, mas a execução final é ignorada. Quando nenhum erro é encontrado, uma resposta em branco é retornada. Quando há falha na avaliação, mensagens de erro indicam os pontos de falha.

Veja um exemplo de como configurar o campo validateOnly usando a biblioteca Java.

Credential oAuth2Credential = new OfflineCredentials.Builder()
    .forApi(Api.ADWORDS)
    .fromFile()
    .build()
    .generateCredential();

AdWordsSession session = new AdWordsSession.Builder()
    .fromFile()
    .withOAuth2Credential(oAuth2Credential)
    .build();

session.setValidateOnly(true);

As chamadas de API realizadas usando essa sessão têm o cabeçalho validateOnly definido como true.

O cabeçalho validateOnly é especialmente útil para testar os anúncios e descobrir se há violações comuns da política. Os anúncios que violam as políticas (por exemplo, ao usar determinadas palavras, durações, letras maiúsculas ou pontuação) são rejeitados automaticamente. Quando você tenta fazer o upload de anúncios em lote, mas um deles está com problema, pode ocorrer falha em todo o restante do lote. Ao testar um novo anúncio com o campo validateOnly, você pode ver facilmente quais anúncios seriam rejeitados. Consulte o exemplo de código sobre como lidar com erros de violação de política para ver como isso funciona.

Caso você não esteja usando uma biblioteca de cliente, basta configurar o cabeçalho SOAP correto para continuar validando suas solicitações mutate().

Serviços da Google AdWords API

Esta seção descreve os serviços fornecidos pela Google AdWords API, com links para páginas de referência que contêm detalhes adicionais de cada serviço.

Os serviços da Google AdWords API podem ser agrupados em quatro categorias funcionais:

Gerenciamento de dados de campanhas

Use os serviços de gerenciamento de dados de campanhas para trabalhar com as campanhas do Google AdWords e suas entidades associadas. Cada serviço de gerenciamento de dados de campanhas corresponde a uma entidade na hierarquia de dados de campanhas.

Serviço Descrição
CampaignService Criar, atualizar e remover campanhas. Uma campanha organiza um ou mais grupos de anúncios e tem suas próprias configurações de segmentação, período de veiculação, estratégia de lances e orçamento.
AdGroupService Criar, atualizar e remover grupos de anúncios. Um grupo de anúncios organiza um conjunto de anúncios e critérios ao mesmo tempo, além de especificar o lance padrão para seus critérios.
AdGroupAdService Criar, atualizar e remover anúncios.
CampaignExtensionSettingService Criar, atualizar e remover extensões de anúncio. As extensões de anúncio das campanhas aprimoram os anúncios de texto padrão incluindo informações de local, links adicionais ou um número de telefone em todos os anúncios de uma campanha.
CampaignCriterionService
AdGroupCriterionService
Criar, atualizar e remover critérios. Um critério descreve as condições que determinam se um anúncio deve ser exibido.
ConversionTrackerService
OfflineConversionFeedService
Avaliar a eficiência dos anúncios e palavras-chave ao descobrir o que acontece depois que um usuário clica no seu anúncio. O serviço OfflineConversionFeedService lida com a importação de conversões off-line.
DataService Recuperar os dados de gerenciamento de campanhas de anúncios com base nos critérios especificados.
FeedService
FeedItemService
FeedMappingService
AdGroupFeedService
CampaignFeedService
Criar feeds de dados personalizados para gerenciar extensões de link no aplicativo, telefone e site.
AdwordsUserListService Criar, atualizar e remover listas de usuários. As listas de usuários e seus respectivos critérios exibem anúncios às pessoas que já acionaram um evento de conversão no seu website.
BudgetService Criar, atualizar e remover os orçamentos. Usado para gerenciar orçamentos que podem ser compartilhados em diferentes campanhas.

Otimização

Use os serviços de otimização para recuperar estatísticas de desempenho e ter ideias para novos critérios.

Serviço Descrição
ReportDefinitionService Criar e fazer o download de vários relatórios de desempenho.
TargetingIdeaService Gerar novas ideias de canais e palavras-chave com base nos parâmetros que você especifica,
TrafficEstimatorService Ver estimativas de tráfego para as campanhas, as palavras-chave e os grupos de anúncios propostos.
DraftService e TrialService Criar novos rascunhos e testes para analisar as configurações da sua campanha. Veja este guia para mais detalhes.

Gerenciamento da conta

Utilizar os serviços de gerenciamento da conta para acompanhar a atividade da sua conta.

Serviço Descrição
CustomerService Recuperar detalhes básicos sobre a conta de um cliente.
CustomerSyncService Recuperar um registro de alterações de dados de campanhas em um período específico.
ManagedCustomerService Gerenciar contas de cliente e vinculações entre contas de cliente e de administrador.

Utilitário

Use estes serviços de utilitário para realizar várias tarefas úteis com a Google AdWords API.

Serviço Descrição
BatchJobService Processar de modo assíncrono um grande lote de operações de dados de campanhas. Comparadas às chamadas síncronas para os serviços da Web padrão, as tarefas de processamento em lote levam mais tempo para serem concluídas, mas oferecem outras vantagens, conforme descrito no guia sobre processamento em lote.
MediaService Fazer o upload e recuperar os códigos de mídia que você utiliza em anúncios com base em mídia (como anúncios gráficos ou em vídeo).
ConstantDataService Recuperar valores constantes utilizados pela API.
LocationCriterionService Recuperar o código de um critério "Location".

Dados da campanha

O trabalho com os dados da campanha é uma das tarefas fundamentais que você realiza com a Google AdWords API. A tabela abaixo descreve cada entidade de dados da campanha e sua relação com outros dados da campanha.

Entidade
Entidades filha (quantidade)
Tipo de dados Descrição
Campanha
Grupos de anúncios (1+)
Listas de segmentações da campanha (7)
Extensões de anúncio da campanha (0+)
Critérios da campanha (0+)
Campaign As campanhas organizam um ou mais grupos de anúncios e têm os próprios período de veiculação, estratégia de lances e orçamento.
Grupo de anúncios
Anúncios (1+)
Critérios (1+)
AdGroup
Um grupo de anúncios organiza um conjunto de anúncios e critérios, além de especificar o lance padrão para os critérios dele.
Anúncio
Modificações de extensões de anúncio (0+)
AdGroupAd Os tipos de anúncio disponíveis são documentados na referência da API como subclasses do tipo Ad abstrato.
Critério
Nenhum
AdGroupCriterion, CampaignCriterion Um critério descreve as condições que determinam se um anúncio deve ser exibido (critério disponível para lances) ou não (critério negativo). Um critério de grupo de anúncios afeta os anúncios no grupo de anúncios pai. Um critério de campanha, que sempre é negativo, define condições que impedem a exibição dos anúncios da campanha.
Extensão de anúncio
Nenhum
CampaignExtensionSetting As extensões das campanhas melhoram os anúncios de texto padrão ao incluir em todos eles informações de local, links adicionais ou um número de telefone.
Feed
Nenhum
Feed Os feeds funcionam como canais de dados para as extensões de anúncio (sitelink, telefone, aplicativo).
Lista de usuários
Nenhum
UserList As listas de usuários acompanham os usuários que já demonstraram interesse no seu site. Você pode segmentar os anúncios a este conjunto de usuários. Para isso, crie um critério de lista de usuários e vincule-o a uma lista de usuários existente.
Orçamento
Nenhum
Budget Os orçamentos são usados para gerenciar a quantidade de dinheiro gasto nas campanhas. Um orçamento pode ser compartilhado entre diferentes campanhas, e o sistema determina a alocação ideal.

Enviar comentários sobre…

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