Jetzt starten

In diesem Leitfaden wird erklärt, wie Sie Anwendungen schreiben, in denen die REST API für Ad Exchange-Käufer verwendet wird, um mit DoubleClick Ad Exchange zu interagieren. Mit der REST API für Ad Exchange-Käufer kann Ihre Anwendung für Echtzeitgebote auf Kontoinformationen zugreifen, diese aktualisieren und Creatives übermitteln. Außerdem kann eine Anwendung, unabhängig davon, ob mit ihr statische oder Echtzeitgebote abgegeben werden, dank der API direkte Deals ermitteln, die von Verkäufern angeboten werden.

Die aktuelle und empfohlene Version der REST API für Ad Exchange-Käufer ist Version 1.4.

Es steht auch Version 2 der API als offene Betaversion zur Verfügung, die die neuesten Entwicklungen und Funktionen umfasst.

Falls Ihnen die Konzepte von Ad Exchange für Käufer nicht bekannt sind, finden Sie Informationen in der DoubleClick Ad Exchange-Hilfe. Zudem können Sie einfach die Benutzeroberfläche erkunden.

Auf die Autorisierung vorbereiten

Führen Sie die folgenden Schritte aus, um sich auf die Authentifizierung mit OAuth 2.0 vorzubereiten. Die API unterstützt viele verschiedene Arten von Anmeldedaten. Im folgenden Beispiel verwenden wir ein Dienstkonto.

  1. Öffnen Sie die Seite für aktivierte APIs in der Google API-Konsole.
  2. Wählen Sie im Drop-down-Menü mit den Projekten ein Projekt aus oder erstellen Sie ein neues.
  3. Stellen Sie sicher, dass in der Liste Aktivierte APIs die API für Ad Exchange-Käufer aufgeführt ist. Ist dies nicht der Fall, klicken Sie auf den Tab Google APIs, suchen Sie die API für Ad Exchange-Käufer, wählen Sie sie aus und klicken Sie dann auf API aktivieren.
  4. Wählen Sie dann in der linken Seitenleiste Anmeldedaten aus.
  5. Klicken Sie im Drop-down-Menü Anmeldedaten erstellen auf Dienstkontoschlüssel.
  6. Wählen Sie im Drop-down-Menü Dienstkonto die Option Neues Dienstkonto aus.
  7. Geben Sie unter Name einen Namen für das Dienstkonto ein. Die Dienstkonto-ID wird anhand des Namens und des Projektnamens automatisch generiert.
  8. Notieren Sie sich die Dienstkonto-ID. Sie benötigen sie, um dem neuen Dienstkonto in Schritt 11 auf der Ad Exchange-Benutzeroberfläche Zugriff zu gewähren.
  9. Wählen Sie für Schlüsseltyp die empfohlene JSON-Datei oder eine P12-Datei aus, falls die Abwärtskompatibilität mit dem Code erforderlich ist.
  10. Klicken Sie auf Erstellen. Die JSON- oder P12-Datei mit dem öffentlichen/privaten Schlüsselpaar des Kontos wird im Ordner "Downloads" gespeichert. Legen Sie die generierte JSON- oder P12-Datei an einem sicheren Speicherplatz ab.
  11. Damit das Dienstkonto funktioniert, müssen Sie ihm auf der Ad Exchange-Benutzeroberfläche Zugriff gewähren. Wählen Sie Einstellungen > Kontoeinstellungen und dann Nutzerverwaltung > Kontonutzer aus und klicken Sie anschließend auf + Dienstkonto. Geben Sie die Dienstkonto-ID ein, die Sie sich in Schritt 8 notiert haben. Dadurch wird ein neuer Nutzer mit der Rolle "Dienstkonto" erstellt.

Weitere Informationen finden Sie im Leitfaden zur Autorisierung.

API aufrufen

Auf den Tabs unten finden Sie Kurzanleitungen für das Codieren in den einzelnen Sprachen, für die eine Clientbibliothek vorhanden ist.

Java

Nachfolgend sehen Sie ein einfaches Beispiel, in dem veranschaulicht wird, wie die REST API für Ad Exchange-Käufer mit Java verwendet wird.

  1. Maven-Projekt in Eclipse erstellen

    Öffnen Sie die Datei "pom.xml" und fügen Sie folgende Abhängigkeiten hinzu:

      <dependencies>
        <dependency>
          <groupId>com.google.apis</groupId>
          <artifactId>google-api-services-adexchangebuyer</artifactId>
          <version>RELEASE</version>
        </dependency>
        <dependency>
          <groupId>com.google.http-client</groupId>
          <artifactId>google-http-client-jackson2</artifactId>
          <version>RELEASE</version>
        </dependency>
      </dependencies>
      

  2. Anmeldedaten einrichten

    Für alle API-Aufrufe ist eine Authentifizierung erforderlich. Erstellen Sie wie oben beschrieben ein Credential-Element über die E-Mail-Adresse des Dienstkontos und die P12-Datei.

    Credential oAuth2Credential = new GoogleCredential.Builder()
            .setTransport(httpTransport)
            .setJsonFactory(jsonFactory)
            .setServiceAccountId(SERVICE_ACCOUNT_EMAIL)
            .setServiceAccountScopes(AdExchangeBuyerScopes.all())
            .setServiceAccountPrivateKeyFromP12File(P12_FILE)
            .build();
  3. Client für AdExchangeBuyer einrichten

    Erstellen Sie AdExchangeBuyer über das Builder-Muster:

    AdExchangeBuyer buyerService = new AdExchangeBuyer.Builder(httpTransport,
            jsonFactory, oAuth2Credential).setApplicationName(APPLICATION_NAME)
            .build();

  4. Aktion ausführen

    Nachdem Sie einen Client für das Verbinden mit der API instanziiert haben, können Sie eine Aktion ausführen. Über den folgenden Code werden alle Account-Objekte des Käufers zurückgegeben, die mit dem authentifizierten Konto verknüpft sind.

    List<Account> allAccounts = buyerService.accounts().list()
            .execute().getItems();
    
        if (allAccounts != null && allAccounts.size() > 0) {
          System.out.printf("Listing of user associated accounts%n");
          for (Account account : allAccounts) {
            System.out.printf("Account id: %d%n", account.getId());
          }
        }

Weitere Informationen zur Verwendung der REST API für Ad Exchange-Käufer mit Java finden Sie in der README-Datei in den Beispielen für die REST API für Ad Exchange-Käufer.

Python

Nachfolgend sehen Sie ein einfaches Beispiel, in dem veranschaulicht wird, wie die REST API für Ad Exchange-Käufer mit Python verwendet wird.

  1. Python-Client für die Google API herunterladen und installieren

    Beispiel unter Verwendung von pip:

    $ pip install --upgrade google-api-python-client

  2. Anmeldedaten einrichten

    Für alle API-Aufrufe ist eine Authentifizierung erforderlich. Erstellen Sie wie oben beschrieben Anmeldedaten über die E-Mail-Adresse des Dienstkontos und die P12-Datei. Verwenden Sie die Anmeldedaten, um ein Http-Objekt zu autorisieren.

      oauth_credentials = client.SignedJwtAssertionCredentials(
          SERVICE_ACCOUNT_EMAIL,
          open(KEY_FILE).read(),
          scope=SCOPE)
    
      # Use the credentials to authorize an Http object
      http = oauth_credentials.authorize(httplib2.Http())
  3. Client für AdExchangeBuyer einrichten

    Sie können Ihren AdExchangeBuyer-Client dann mithilfe des autorisierten Http-Objekts erstellen:

    buyer_service = build('adexchangebuyer', VERSION, http=http)

  4. Aktion ausführen

    Nachdem Sie einen Client für das Verbinden mit der API instanziiert haben, können Sie eine Aktion ausführen. Über den folgenden Code werden alle Account-Objekte des Käufers zurückgegeben, die mit dem authentifizierten Konto verknüpft sind.

    request = buyer_service.accounts().list()

Weitere Informationen zur Verwendung der REST API für Ad Exchange-Käufer mit Python finden Sie in der README-Datei in den Beispielen für die REST API für Ad Exchange-Käufer.

PHP

Nachfolgend sehen Sie ein einfaches Beispiel, in dem veranschaulicht wird, wie die REST API für Ad Exchange-Käufer mit PHP verwendet wird.

  1. Abhängigkeiten einrichten

    Laden Sie google-api-php-client herunter und installieren Sie die Bibliothek.

  2. Client einrichten

    Erstellen Sie ein Google_Client-Objekt.

    $client = new Google_Client();
    $client->setApplicationName(
        'DoubleClick Ad Exchange Buyer REST API PHP Samples');
  3. Anmeldedaten einrichten

    Für alle API-Aufrufe ist ein gültiges Zugriffstoken erforderlich. Sie erhalten ein Zugriffstoken, indem Sie Ihren vorkonfigurierten Schlüssel bereitstellen.

    $service = new Google_Service_AdExchangeBuyer($client);
    
    if (isset($_SESSION['service_token'])) {
        $client->setAccessToken($_SESSION['service_token']);
    }
    
    $client->setAuthConfig($key_file_location);
    $client->addScope('https://www.googleapis.com/auth/adexchange.buyer');
    
    if ($client->isAccessTokenExpired()) {
        $client->refreshTokenWithAssertion();
    }
    
    $_SESSION['service_token'] = $client->getAccessToken();
  4. Client für AdExchangeBuyer einrichten

    Sie können Ihren AdExchangeBuyer-Client dann mithilfe des autorisierten Google_Client-Objekts erstellen:

    $service = new Google_Service_AdExchangeBuyer($client);

  5. Aktion ausführen

    Nachdem Sie einen Client für das Verbinden mit der API instanziiert haben, können Sie eine Aktion ausführen. Über den folgenden Code werden alle Account-Objekte des Käufers zurückgegeben, die mit dem authentifizierten Konto verknüpft sind.

    $result = $service->accounts->listAccounts();
    
        print '<h2>Listing of user associated accounts</h2>';
        if (! isset($result['items']) || ! count($result['items'])) {
            print '<p>No accounts found</p>';
            return;
        } else {
            foreach ($result['items'] as $account) {
                printf('<pre>');
                print_r($account);
                printf('</pre>');
            }
        }

Weitere Informationen zur Verwendung der REST API für Ad Exchange-Käufer mit PHP finden Sie in der README-Datei in den Beispielen für die REST API für Ad Exchange-Käufer.

.NET

Nachfolgend sehen Sie ein einfaches Beispiel, in dem veranschaulicht wird, wie die REST API für Ad Exchange-Käufer mit C# verwendet wird.

  1. Neues Projekt erstellen

    Öffnen Sie Visual Studio und erstellen Sie ein neues Projekt vom Typ "Konsolenanwendung".

  2. Dem Projekt die erforderlichen Bibliothekreferenzen hinzufügen

    Hierzu stehen Ihnen die folgenden beiden Möglichkeiten zur Verfügung:

    1. Verwenden Sie NuGet, um die neueste Version von Google.Apis.AdExchangeBuyer und der zugehörigen Abhängigkeiten hinzuzufügen.
    2. Laden Sie die Bibliothek manuell herunter und fügen Sie den DLLs eine Referenz hinzu. Weitere Informationen zur Bibliothek

  3. Anmeldedaten einrichten

    Für alle API-Aufrufe ist eine Authentifizierung erforderlich. Erstellen Sie wie oben beschrieben ein Credential-Element über die E-Mail-Adresse des Dienstkontos und die JSON-Datei.

    ServiceAccountCredential oAuth2Credentials = new ServiceAccountCredential(
                    new ServiceAccountCredential.Initializer(
                        credentialParameters.ClientEmail)
                    {
                        Scopes = new[] { AdExchangeBuyerService.Scope.AdexchangeBuyer }
                    }.FromPrivateKey(credentialParameters.PrivateKey));
  4. Client für AdExchangeBuyer einrichten

    Sie können jetzt Ihren AdExchangeBuyerService-Client erstellen:

    AdExchangeBuyerService buyerService = new AdExchangeBuyerService(
                    new BaseClientService.Initializer
                    {
                        HttpClientInitializer = oAuth2Credentials,
                        ApplicationName = "FirstAPICall"
                    });
  5. Aktion ausführen

    Nachdem Sie einen Client für das Verbinden mit der API instanziiert haben, können Sie eine Aktion ausführen. Über den folgenden Code werden alle Account-Objekte des Käufers zurückgegeben, die mit dem authentifizierten Konto verknüpft sind.

    AccountsList allAccounts = buyerService.Accounts.List().Execute();
    
                foreach (Account account in allAccounts.Items)
                {
                    Console.WriteLine("Account id: {0}", account.Id);
                }
    

Weitere Informationen zur Verwendung der REST API für Ad Exchange-Käufer mit C# finden Sie in der README-Datei in den Beispielen für die REST API für Ad Exchange-Käufer.

Ruby

Nachfolgend sehen Sie ein einfaches Beispiel, in dem veranschaulicht wird, wie die REST API für Ad Exchange-Käufer mit Ruby verwendet wird.

  1. Ruby-Client für die Google API herunterladen und installieren

    Beispiel unter Verwendung von gem:

    $ gem install google-api-client
    $ gem update -y google-api-client

  2. Anmeldedaten einrichten

    Für alle API-Aufrufe ist eine Authentifizierung erforderlich. Erstellen Sie wie oben beschrieben Anmeldedaten über die E-Mail-Adresse des Dienstkontos und die JSON-Datei.

    # Create credentials using the JSON key file.
      auth_options = {
        :json_key_io => File.open(KEY_FILE, "r"),
        :scope => "https://www.googleapis.com/auth/adexchange.buyer"
      }
    
      oauth_credentials = Google::Auth::ServiceAccountCredentials.make_creds(
        options=auth_options
      )
  3. Client für AdExchangeBuyer einrichten

    Sie können Ihren autorisierten AdExchangeBuyer-Client dann mithilfe der Anmeldedaten erstellen:

    # Create the service and set credentials
      ad_exchange_buyer = (
        Google::Apis::AdexchangebuyerV1_4::AdExchangeBuyerService.new
      )
      ad_exchange_buyer.authorization = oauth_credentials
      ad_exchange_buyer.authorization.fetch_access_token!
  4. Aktion ausführen

    Nachdem Sie einen Client für das Verbinden mit der API instanziiert haben, können Sie eine Aktion ausführen. Über den folgenden Code werden alle Account-Objekte des Käufers zurückgegeben, die mit dem authentifizierten Konto verknüpft sind.

    # Call the Accounts resource on the service to retrieve a list of
        # Accounts for the service account.
        accounts_list = ad_exchange_buyer.list_accounts()
    
        if accounts_list.items.any?
          puts 'Found the following DoubleClick Ad Exchange Buyer Accounts:'
          accounts_list.items.each do |account|
            puts 'AccountID: %d' % account.id
            puts "\tCookie matching nid: %s" % account.cookie_matching_nid
            puts "\tCookie matching URL: %s" % account.cookie_matching_url
            puts "\tMaximum active creatives: %d" % account.maximum_active_creatives
            puts "\tMaximum total QPS: %d" % account.maximum_total_qps
            puts "\tNumber active creatives: %d" % account.number_active_creatives
            puts "\tBidder Locations:"
            account.bidder_location.each do |bidder_location|
              puts "\t\tURL: %s" % bidder_location.url
              puts "\t\t\tRegion: %s" % bidder_location.region
              puts "\t\t\tBid Protocol: %s" % bidder_location.bid_protocol
              puts "\t\t\tMaximum QPS: %s" % bidder_location.maximum_qps
            end
          end
        else
          puts 'No DoubleClick Ad Exchange Buyer Accounts were found.'
        end

Weitere Informationen zur Verwendung der REST API für Ad Exchange-Käufer mit Ruby finden Sie in der README-Datei in den Beispielen für die REST API für Ad Exchange-Käufer.

API mit der offenen Betaversion (Version 2) aufrufen

Auf den Tabs unten finden Sie Kurzanleitungen für das Codieren in den einzelnen Sprachen, für die eine Clientbibliothek vorhanden ist.

Java

/*
 * Copyright (c) 2016 Google Inc.
 *
 * 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.
 */

package com.google.api.services.samples.adexchangebuyer.cmdline;

import com.google.api.client.googleapis.services.json.AbstractGoogleJsonClient;
import com.google.api.services.adexchangebuyer2.v2beta1.AdExchangeBuyerII;
import com.google.api.services.adexchangebuyer2.v2beta1.model.Client;

import java.io.IOException;
import java.util.List;

/**
 * This sample illustrates how to retrieve all client buyers associated with a given account.
 *
 * See the <a href="Client Buyers Guide">https://developers.google.com/ad-exchange/buyer-rest/guides/client-access/clients</a>
 * for more details on the usage of this resource.
 */
public class GetAllClientBuyers extends BaseSample {
  @Override
  public ClientType getClientType() {
    return BaseSample.ClientType.ADEXCHANGEBUYERII;
  }

  @Override
  public String getName() {
    return "Get All Client Buyers";
  }

  @Override
  public String getDescription() {
    return "Lists Client Buyers associated with the given Account.";
  }

  @Override
  public void execute(AbstractGoogleJsonClient client) throws IOException {
    AdExchangeBuyerII adXClient = (AdExchangeBuyerII) client;
    long accountId = getIntInput("AccountId", "Enter the Account ID");
    List<Client> allClients = adXClient.accounts().clients().list(accountId).execute().getClients();

    if (allClients != null && allClients.size() > 0) {
      System.out.printf("========================================\n");
      System.out.printf("Listing of Client Buyers associated with AdX Account \"%s\"%n",
          accountId);
      System.out.printf("========================================\n");
      for (Client clientBuyer : allClients) {
        System.out.printf("Client Account ID: %s%n", clientBuyer.getClientAccountId());
        System.out.printf("\tClient Name: %s%n", clientBuyer.getClientName());
        System.out.printf("\tEntity ID: %s%n", clientBuyer.getEntityId());
        System.out.printf("\tEntity Name: %s%n", clientBuyer.getEntityName());
        System.out.printf("\tEntity Type: %s%n", clientBuyer.getEntityType());
        System.out.printf("\tRole: %s%n", clientBuyer.getRole());
        System.out.printf("\tStatus: %s%n", clientBuyer.getStatus());
      }
    } else {
      System.out.println("No Client Buyers were found associated to this Account.");
    }
  }
}

Python

#!/usr/bin/python
#
# Copyright 2016 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.

"""This example lists the client buyers for a given account."""

import argparse
import pprint
import sys

from apiclient.errors import HttpError
from oauth2client.client import AccessTokenRefreshError
import samples_util

DEFAULT_ACCOUNT_ID = 'ENTER_ACCOUNT_ID_HERE'

def main(ad_exchange_buyer, account_id):
  try:
    # Construct and execute the request.
    clients = ad_exchange_buyer.accounts().clients().list(
        accountId=account_id).execute()
    print 'Client buyers for account ID: %d' % account_id
    pprint.pprint(clients)
  except HttpError as e:
    print e

if __name__ == '__main__':
  parser = argparse.ArgumentParser(
      description='Lists client buyers for a given Ad Exchange account id.')
  parser.add_argument(
      '-a', '--account_id', default=DEFAULT_ACCOUNT_ID, type=int,
      help=('The integer id of the Ad Exchange account.'))
  args = parser.parse_args()

  try:
    service = samples_util.GetService(version='v2beta1')
  except IOError, ex:
    print 'Unable to create adexchangebuyer service - %s' % ex
    print 'Did you specify the key file in samples_util.py?'
    sys.exit()
  except AccessTokenRefreshError, ex:
    print 'Unable to create adexchangebuyer service - %s' % ex
    print 'Did you set the correct Service Account Email in samples_util.py?'
    sys.exit()

  main(service, args.account_id)

PHP

<?php
/*
 * Copyright 2016 Google Inc.
 *
 * 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.
 */

// Require the base class.
require_once __DIR__ . "/../BaseExample.php";

/**
 * This example illustrates how to retrieve all buyer clients associated
 * with a given account.
 */
class ListClientBuyers extends BaseExample
{

    /**
     *
     * @see BaseExample::getInputParameters()
     */
    protected function getInputParameters()
    {
        return array(
            array(
                'name' => 'account_id',
                'display' => 'Account id',
                'required' => true
            )
        );
    }

    /**
     *
     * @see BaseExample::run()
     */
    public function run()
    {
        $values = $this->formValues;
        $result = $this->service->accounts_clients->listAccountsClients(
            $values['account_id']);
        print '<h2>Listing buyer clients</h2>';
        if (! isset($result['clients']) || ! count($result['clients'])) {
            print '<p>No buyer clients found</p>';
            return;
        } else {
            foreach ($result['clients'] as $clients) {
                $this->printResult($clients);
            }
        }
    }

    /**
     *
     * @see BaseExample::getClientType()
     */
    function getClientType()
    {
        return ClientType::AdExchangeBuyerII;
    }

    /**
     *
     * @see BaseExample::getName()
     */
    public function getName()
    {
        return 'Client Access: List Client Buyers';
    }
}

.NET

/* Copyright 2016, 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.
 */

using Google.Apis.AdExchangeBuyerII.v2beta1;
using Google.Apis.AdExchangeBuyerII.v2beta1.Data;
using Google.Apis.Services;

using System;

namespace Google.Apis.AdExchangeBuyer.Examples.v2_x
{
    /// <summary>
    /// Retrieves the authenticated user's list of client buyers for the given
    /// account ID.
    /// </summary>
    public class ListClientBuyers : ExampleBase
    {
        /// <summary>
        /// Main method, to run this code example as a standalone application.
        /// </summary>
        /// <param name="args">The command line arguments</param>
        public static void Main(string[] args)
        {
            AdExchangeBuyerIIService service = Utilities.GetV2Service();
            ExampleBase example = new ListClientBuyers();
            Console.WriteLine(example.Description);

            example.Run(service);
        }

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get { return "This code example lists all client buyers for a "
                    + "given account ID."; }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="service">An authenticated AdExchangeBuyerIIService</param>
        public override void Run(BaseClientService service)
        {
            AdExchangeBuyerIIService adXService =
                (AdExchangeBuyerIIService)service;
            long accountId = long.Parse("INSERT ACCOUNT ID HERE");

            ListClientsResponse response = adXService.Accounts.Clients
                .List(accountId).Execute();

            Console.WriteLine("========================================\n");
            Console.WriteLine("Listing of client buyers associated with AdX "
                + "Account \"{0}\"", accountId);
            Console.WriteLine("========================================\n");

            if (response.Clients.Count == 0)
            {
                Console.WriteLine("No client buyers found.");
            } else
            {
                foreach (Client clientBuyer in response.Clients)
                {
                    Console.WriteLine("Client Account ID: {0}", clientBuyer.ClientAccountId);
                    Console.WriteLine("\tClient Name: {0}", clientBuyer.ClientName);
                    Console.WriteLine("\tEntity ID: {0}", clientBuyer.EntityId);
                    Console.WriteLine("\tEntity Name: {0}", clientBuyer.EntityName);
                    Console.WriteLine("\tEntity Type: {0}", clientBuyer.EntityType);
                    Console.WriteLine("\tRole: {0}", clientBuyer.Role);
                    Console.WriteLine("\tStatus: {0}", clientBuyer.Status);
                }
            }
        }

        public override ClientType getClientType()
        {
            return ClientType.ADEXCHANGEBUYERII;
        }
    }
}

Ruby

#!/usr/bin/env ruby
# Encoding: utf-8
#
# Copyright:: Copyright 2016, Google Inc. All Rights Reserved.
#
# License:: 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.
#
# Lists the client buyers for a given account.
#
# To get Account IDs, run list_accounts.rb.
#
# Tags: Accounts.Clients.list

require 'optparse'

require_relative 'samples_util'

def list_client_buyers(ad_exchange_buyer, account_id, page_size)
  begin
    client_buyers = ad_exchange_buyer.list_account_clients(
      account_id, page_size: page_size
    )

    if !client_buyers.clients.nil?
      puts 'Found the following client buyers for account ID %s:' % account_id
      client_buyers.clients.each do |client_buyer|
        puts '* Client account ID: %s' % client_buyer.client_account_id
        puts "\tClient name: %s" % client_buyer.client_name
        puts "\tEntity ID: %s" % client_buyer.entity_id
        puts "\tEntity name: %s" % client_buyer.entity_name
        puts "\tEntity Type: %s" % client_buyer.entity_type
        puts "\tRole: %s" % client_buyer.role
        puts "\tStatus: %s" % client_buyer.status
        puts "\tVisible to seller: %s" % client_buyer.visible_to_seller
      end
    else
      puts 'No client buyers found for account ID %s.' % account_id
    end

  rescue Google::Apis::ServerError => e
    puts "The following server error occured:\n%s" % e.message
  rescue Google::Apis::ClientError => e
    puts "Invalid client request:\n%s" % e.message
  rescue Google::Apis::AuthorizationError => e
    puts "Authorization error occured:\n%s" % e.message
  end
end

if __FILE__ == $0
  begin
    # Retrieve the service used to make API requests.
    service = get_service(version=ADEXCHANGEBUYER_V2BETA1)
  rescue ArgumentError => e
    puts 'Unable to create service: %s' % e.message
    puts 'Did you specify the key file in util.rb?'
    exit
  rescue Signet::AuthorizationError => e
    puts e.message
    puts 'Did you set the correct Service Account Email in samples_util.rb?'
    exit
  end

  # Set options and default values for fields used in this example.
  options = [
    Option.new(
      'account_id', 'The integer ID of the Ad Exchange buyer account.',
      :type => Integer, :short_alias => 'a', :required => true,
      :default_value => nil  # Insert default value here.
    ),
    Option.new(
      'max_page_size',
      'The maximum number of entries returned on one result page.',
      :type => Integer, :short_alias => 'm', :required => true,
      :default_value => MAX_PAGE_SIZE
    )
  ]

  # Parse options.
  parser = Parser.new(options)
  opts = parser.parse(ARGV)

  list_client_buyers(service, opts['account_id'], opts['page_size'])
end

Weitere Informationen

  • Im Leitfaden mit Hintergrundinformationen erfahren Sie, was bei den unterschiedlichen Beispielen und Optionen geschieht, die Ihnen bei der Entwicklung Ihrer Lösung zur Verfügung stehen.
  • Wenn Sie eine Clientbibliothek eingerichtet haben und diese aktiv ist, erweitern Sie die Codebeispiele so, dass Sie Ihren Anforderungen entsprechen.
  • Rufen Sie die Referenzdokumentation für die Version auf, die Sie verwenden, um weitere Informationen zur API zu erhalten.
  • Wenn Sie Hilfe benötigen, besuchen Sie unser Forum.
  • Wenn über Ihre Anwendung Echtzeitgebote ausgeführt werden sollen, erhalten Sie weitere Informationen dazu in der Dokumentation zum EZG-Protokoll von Ad Exchange.
  • Sehen Sie sich die Tipps zur Leistungssteigerung an.

An der Umfrage teilnehmen

Helfen Sie uns dabei, diese Dokumentation zu verbessern. Teilen Sie uns mit, was funktioniert hat und was in der Dokumentation fehlt. Füllen Sie dazu bitte diese kurze Umfrage aus.

Feedback geben zu...

DoubleClick Ad Exchange Buyer API
DoubleClick Ad Exchange Buyer API