開始使用

透過集合功能整理內容 你可以依據偏好儲存及分類內容。

Authorized Buyers API 有兩種:

  • 即時出價 API (最新版本)
  • Ad Exchange 買方 API II

這些 API 可讓應用程式與 Authorized Buyers 互動,以便:

  • 存取即時出價帳戶資訊
  • 提交及管理正在審核的廣告素材
  • 擷取即時出價疑難排解指標
  • 管理使用者名單
  • 管理預先指定設定
  • 設定 Marketplace 的用戶端存取權
  • 在市集中探索及管理交易提案

如果您不熟悉 Authorized Buyers 概念,請造訪 Authorized Buyers 說明中心,並試用 UI

準備授權

請完成下列步驟,以使用 OAuth 2.0 準備驗證。API 支援多種憑證,在這個範例中將使用服務帳戶。

  1. 前往「Google API 控制台已啟用的 API」頁面

  2. 在專案下拉式選單中選取專案或建立新專案。

  3. 在「已啟用的 API」清單中,確認已列出 Ad Exchange Buyer API。如果未列出,請按一下「Google API」分頁標籤,搜尋並選取 Ad Exchange Buyer API,然後按一下「Enable API」(啟用 API)

  4. 接著,在左側欄中,選取「憑證」

  5. 選取「建立憑證」下拉式選單,然後選擇「服務帳戶金鑰」

  6. 在「服務帳戶」下拉式選單中,選擇「新增服務帳戶」

  7. 輸入服務帳戶的名稱服務帳戶 ID 是透過名稱和專案名稱自動產生。

  8. 記下服務帳戶 ID:在步驟 11 中,您必須使用服務帳戶 ID 來授予新服務帳戶的存取權。

  9. 選擇金鑰類型 (建議使用的 JSON 檔案);如果需要使用 P12 格式的程式碼回溯相容,請選擇 P12。

  10. 按一下「建立」,含有帳戶公開/私密金鑰配對的 JSON 或 P12 檔案會儲存在「下載」資料夾中。將產生的 JSON 或 P12 檔案保存在安全的地方。

  11. 您必須在 Authorized Buyers UI 中授予服務帳戶的存取權,其才能正常運作。依序選取「設定」>「帳戶設定」,然後依序選擇「使用者管理」>「帳戶使用者」,然後按一下「+ 服務帳戶」。輸入您在上方步驟 8 中提及的服務帳戶 ID。這項操作會建立具備服務帳戶角色的使用者。

OAuth 範圍

逐步執行 OAuth 2.0 授權流程時,應用程式可以指定範圍,指定打算存取特定 Google 帳戶的 Google API 中的特定功能。若要代表 Authorized Buyers 帳戶存取任何 Authorized Buyers API,您必須指定要使用的 API 範圍。

Marketplace API

以下是存取 Marketplace API 的範圍:

範圍 意義
https://www.googleapis.com/auth/authorized-buyers-marketplace 讀取/寫入權限。

Real-time Bidding API

以下是存取即時出價 API 的範圍:

範圍 意義
https://www.googleapis.com/auth/realtime-bidding 讀取/寫入權限。

Ad Exchange 買方 API II

以下是存取 Ad Exchange Buyer API II 的範圍:

範圍 意義
https://www.googleapis.com/auth/adexchange.buyer 讀取/寫入權限。

發出 API 呼叫

以下提供幾個範例,說明如何開始使用我們支援的語言:

Marketplace API

Java

/*
 * Copyright 2021 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.api.services.samples.authorizedbuyers.marketplace.v1;

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.authorizedbuyersmarketplace.v1.AuthorizedBuyersMarketplace;
import com.google.api.services.authorizedbuyersmarketplace.v1.AuthorizedBuyersMarketplaceScopes;
import com.google.api.services.authorizedbuyersmarketplace.v1.model.Client;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.auth.oauth2.ServiceAccountCredentials;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * A sample application that authenticates and runs a request against the Authorized Buyers
 * Marketplace API.
 */
public class FirstApiRequest {

  /**
   * Be sure to specify the name of your application. If the application name is {@code null} or
   * blank, the application will log a warning. Suggested format is "MyCompany-ProductName/1.0".
   */
  private static final String APPLICATION_NAME = "APPLICATION_NAME_HERE";

  // Full path to JSON Key file - include file name.
  private static final java.io.File JSON_FILE = new java.io.File("INSERT_PATH_TO_JSON_FILE");

  // Name of the buyer resource for which the API call is being made.
  private static final String BUYER_NAME = "INSERT_BUYER_RESOURCE_NAME";

  // Global instance of the HTTP transport.
  private static HttpTransport httpTransport;

  // Global instance of the JSON factory.
  private static final JsonFactory jsonFactory = GsonFactory.getDefaultInstance();

  public static void main(String[] args) throws Exception {
    // Create credentials using the JSON key file.
    GoogleCredentials credentials = null;

    try (FileInputStream serviceAccountStream = new FileInputStream((JSON_FILE))) {
      Set<String> scopes = new HashSet<>(AuthorizedBuyersMarketplaceScopes.all());
      credentials = ServiceAccountCredentials.fromStream(serviceAccountStream).createScoped(scopes);
    } catch (IOException ex) {
      System.out.println("Can't complete authorization step. Did you specify a JSON key file?");
      System.out.println(ex);
      System.exit(1);
    }

    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(credentials);
    httpTransport = GoogleNetHttpTransport.newTrustedTransport();

    // Use the credentials to create a client for the API service.
    AuthorizedBuyersMarketplace marketplaceClient =
        new AuthorizedBuyersMarketplace.Builder(httpTransport, jsonFactory, requestInitializer)
            .setApplicationName(APPLICATION_NAME)
            .build();

    // Call the buyers.clients.list method to get a list of clients for the given buyer.
    List<Client> clients =
        marketplaceClient.buyers().clients().list(BUYER_NAME).execute().getClients();

    if (clients != null && clients.size() > 0) {
      System.out.printf("Listing of clients associated with buyer \"%s\"%n", BUYER_NAME);
      for (Client client : clients) {
        System.out.printf("* Client name: %s\n", client.getName());
      }
    } else {
      System.out.printf(
          "No clients were found that were associated with buyer \"%s\"%n.", BUYER_NAME);
    }
  }
}

Python

#!/usr/bin/python
#
# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Sample application that authenticates and makes an API request."""

import pprint
from googleapiclient.discovery import build
from google.oauth2 import service_account

# A Service Account key file can be generated via the Google Developers
# Console.
KEY_FILE = 'PATH_TO_JSON_KEY_FILE'  # Path to Service Account JSON key file.

# Authorized Buyers Marketplace API authorization scope.
SCOPE = 'https://www.googleapis.com/auth/authorized-buyers-marketplace'
VERSION = 'v1'  # Version of Authorized Buyers Marketplace API to use.

# Name of the buyer resource for which the API call is being made.
BUYER_NAME = 'BUYER_RESOURCE_NAME'


def main():
  # Create credentials using the Service Account JSON key file.
  credentials = service_account.Credentials.from_service_account_file(
      KEY_FILE, scopes=[SCOPE])

  # Build a client for the authorizedbuyersmarketplace API service.
  marketplace = build('authorizedbuyersmarketplace', VERSION, credentials=credentials)

  # Call the buyers.clients.list method to get a list of clients for the
  # given buyer.
  request = marketplace.buyers().clients().list(parent=BUYER_NAME)

  pprint.pprint(request.execute())


if __name__ == '__main__':
  main()

.NET

/* Copyright 2021 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using Google.Apis.AuthorizedBuyersMarketplace.v1;
using Google.Apis.AuthorizedBuyersMarketplace.v1.Data;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Json;
using Google.Apis.Services;

using System;
using System.Collections.Generic;

namespace Google.Apis.AuthorizedBuyersMarketplace.Examples.v1
{
    /// <summary>
    /// Self contained sample to return a list of clients for a given buyer account.
    /// Primarily used by the Getting Started guide:
    /// https://developers.google.com/authorized-buyers/apis/getting_started
    ///
    /// Note: To run this sample, you will need to configure it as the StartupObject in
    /// Google.Apis.AuthorizedBuyersMarketplace.Examples.csproj.
    /// </summary>
    internal class FirstApiRequest
    {
        private static void Main(string[] args)
        {
            // See the README.md for details of these fields.
            // Retrieved from https://console.developers.google.com
            var ServiceKeyFilePath = "PATH TO JSON KEY FILE HERE";

            // Name of the buyer resource for which the API call is being made.
            var buyerName = "INSERT_BUYER_RESOURCE_NAME_HERE";

            // Retrieve credential parameters from the key JSON file.
            var credentialParameters = NewtonsoftJsonSerializer.Instance
                .Deserialize<JsonCredentialParameters>(
                    System.IO.File.ReadAllText(ServiceKeyFilePath));

            // Create the credentials.
            var credentialInitializer = new ServiceAccountCredential.Initializer(
                    credentialParameters.ClientEmail)
                {
                    Scopes = new[]
                    {
                        AuthorizedBuyersMarketplaceService.Scope.AuthorizedBuyersMarketplace
                    }
                }.FromPrivateKey(credentialParameters.PrivateKey);

            var oAuth2Credentials = new ServiceAccountCredential(credentialInitializer);

            // Use the credentials to create a client for the API service.
            var serviceInitializer = new BaseClientService.Initializer
                {
                    HttpClientInitializer = oAuth2Credentials,
                    ApplicationName = "FirstAPICall"
                };

            var mkService = new AuthorizedBuyersMarketplaceService(serviceInitializer);

            // Call the buyers.clients.list method to list clients for the given buyer.
            BuyersResource.ClientsResource.ListRequest request =
                mkService.Buyers.Clients.List(buyerName);

            IList<Client> clients = request.Execute().Clients;

            foreach (Client client in clients)
            {
                Console.WriteLine("* Client name: {0}", client.Name);
            }

            Console.ReadLine();
        }
    }
}

PHP

<?php

/**
 * Copyright 2022 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Sample application that authenticates and makes an API request.
 */

namespace Google\Ads\AuthorizedBuyers\Marketplace\Examples\V1;

/**
 * Provide path to client library. See README.md for details.
 */
require_once __DIR__ . '/../../vendor/autoload.php';

use Google_Client;
use Google_Service_AuthorizedBuyersMarketplace;


session_start();

/**
 * You can retrieve this file from the Google Developers Console.
 *
 * See README.md for details.
 */
$keyFileLocation = "INSERT_PATH_TO_JSON_KEYFILE";

/**
 * Name of the buyer resource for which the API call is being made.
 */
$buyerName = "INSERT_BUYER_RESOURCE_NAME";

if ($keyFileLocation === 'INSERT_PATH_TO_JSON_KEYFILE') {
    print "WARNING: Authorization details not provided!\n";
    exit(1);
}

$client = new Google_Client();
$client->setApplicationName('Authorized Buyers Marketplace API PHP Samples');

$service = new Google_Service_AuthorizedBuyersMarketplace($client);

$client->setAuthConfig($keyFileLocation);
$client->addScope('https://www.googleapis.com/auth/authorized-buyers-marketplace');

if ($client->isAccessTokenExpired()) {
    $client->refreshTokenWithAssertion();
}

if ($client->getAccessToken()) {
    // Call the buyers.clients.list method to get a list of clients for the given buyer.
    $result = $service->buyers_clients->listBuyersClients($buyerName);

    print "Clients associated with buyer account\n";
    if (empty($result['clients'])) {
        print "No clients found\n";
        return;
    } else {
        foreach ($result['clients'] as $client) {
            print_r($client);
        }
    }
}

Ruby

#!/usr/bin/env ruby
# Encoding: utf-8
#
# Copyright:: Copyright 2022 Google LLC
#
# 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.
#
# Sample application that authenticates and makes an API request.

require 'google/apis/authorizedbuyersmarketplace_v1'
require 'googleauth/service_account'

# You can download the JSON keyfile used for authentication from the Google
# Developers Console.
KEY_FILE = 'path_to_key'  # Path to JSON file containing your private key.

# Name of the buyer resource for which the API call is being made.
BUYER_NAME = 'insert_buyer_resource_name'


def first_api_request()
  # Create credentials using the JSON key file.
  auth_options = {
    :json_key_io => File.open(KEY_FILE, "r"),
    :scope => 'https://www.googleapis.com/auth/authorized-buyers-marketplace'
  }

  oauth_credentials = Google::Auth::ServiceAccountCredentials.make_creds(
    options=auth_options
  )

  # Create the service and set credentials
  marketplace = (
    Google::Apis::AuthorizedbuyersmarketplaceV1::AuthorizedBuyersMarketplaceService.new
  )
  marketplace.authorization = oauth_credentials
  marketplace.authorization.fetch_access_token!

  begin
    # Call the buyers.clients.list method to get list of clients for given buyer.
    clients_list = marketplace.list_buyer_clients(BUYER_NAME)

    if clients_list.clients.any?
      puts "Found the following clients for buyer '%s':" % BUYER_NAME
      clients_list.clients.each do |client|
        puts "* Client name: #{client.name}"
      end
    else
      puts "No clients were found that were associated with buyer '%s'" % BUYER_NAME
    end
  rescue Google::Apis::ServerError => e
    raise "The following server error occured:\n%s" % e.message
  rescue Google::Apis::ClientError => e
    raise "Invalid client request:\n%s" % e.message
  rescue Google::Apis::AuthorizationError => e
    raise "Authorization error occured:\n%s" % e.message
  end
end

if __FILE__ == $0
  begin
    first_api_request()
  end
end

Real-time Bidding API

Java

以下舉例說明如何使用 Java 使用即時出價 API。

  1. 建立 Maven 專案

    開啟 pom.xml 並新增以下依附元件:

    <dependencies>
      <dependency>
        <groupId>com.google.api-client</groupId>
        <artifactId>google-api-client</artifactId>
        <version>1.32.2</version>
      </dependency>
      <dependency>
        <groupId>com.google.apis</groupId>
        <artifactId>google-api-services-pubsub</artifactId>
        <version>v1-rev452-1.25.0</version>
      </dependency>
      <dependency>
        <groupId>com.google.apis</groupId>
        <artifactId>google-api-services-realtimebidding</artifactId>
        <version>v1-rev20220503-1.32.1</version>
      </dependency>
      <dependency>
        <groupId>com.google.auth</groupId>
        <artifactId>google-auth-library-oauth2-http</artifactId>
        <version>1.3.0</version>
      </dependency>
      <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.8.9</version>
      </dependency>
      <dependency>
        <groupId>com.google.http-client</groupId>
        <artifactId>google-http-client-jackson2</artifactId>
        <version>1.40.1</version>
      </dependency>
      <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>2.10.13</version>
      </dependency>
      <dependency>
        <groupId>net.sourceforge.argparse4j</groupId>
        <artifactId>argparse4j</artifactId>
        <version>0.9.0</version>
      </dependency>
    </dependencies>
      

  2. 設定憑證

    所有傳送至 API 的呼叫都需要進行驗證;請使用上述討論的服務帳戶 JSON 金鑰檔案建立 Credential

    GoogleCredentials credentials = null;
    
    try (FileInputStream serviceAccountStream = new FileInputStream((JSON_FILE))) {
      Set<String> scopes = new HashSet<>(RealTimeBiddingScopes.all());
      credentials = ServiceAccountCredentials.fromStream(serviceAccountStream).createScoped(scopes);
    } catch (IOException ex) {
      System.out.println("Can't complete authorization step. Did you specify a JSON key file?");
      System.out.println(ex);
      System.exit(1);
    }
  3. 為即時出價 API 建構用戶端

    接著,您就可以使用建構工具模式建立即時出價 API 用戶端:

    
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(credentials);
    httpTransport = GoogleNetHttpTransport.newTrustedTransport();
    
    // Use the credentials to create a client for the API service.
    RealTimeBidding realtimeBidding =
        new RealTimeBidding.Builder(httpTransport, jsonFactory, requestInitializer)
            .setApplicationName(APPLICATION_NAME)
            .build();

  4. 執行作業

    將用戶端執行個體化為 API 執行個體化之後,您可以執行作業。以下程式碼會傳回所有指定買方的廣告素材。

        List<Creative> creatives =
            realtimeBidding
                .buyers()
                .creatives()
                .list(BUYER_NAME)
                .setView("FULL")
                .execute()
                .getCreatives();
    
        if (creatives != null && creatives.size() > 0) {
          System.out.printf("Listing of creatives associated with buyer '%s'%n", BUYER_NAME);
          for (Creative creative : creatives) {
            System.out.printf("* Creative name: %s\n", creative.getName());
          }
        } else {
          System.out.printf(
              "No creatives were found that were associated with buyer '%s'%n.", BUYER_NAME);
        }

如要進一步瞭解如何搭配 Java 使用即時出價 API,請參閱 即時出價 API 範例中的 README 檔案。

Python

以下舉例說明如何搭配 Python 使用即時出價 API。

  1. 下載並安裝 Google API Python 用戶端

    使用 pip 的範例:

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

  2. 設定憑證

    所有呼叫 API 都需要進行驗證;使用上述的服務帳戶 JSON 金鑰檔案,將 service_account.Credentials 執行個體執行個體化。

      credentials = service_account.Credentials.from_service_account_file(
          KEY_FILE, scopes=[SCOPE])
  3. 為即時出價 API 建構用戶端

    接著,您就可以使用已獲授權的 service_account.Credentials 執行個體建立即時出價 API 用戶端:

    realtimebidding = build('realtimebidding', VERSION, credentials=credentials)

  4. 執行作業

    將用戶端執行個體化為 API 執行個體化之後,您可以執行作業。以下程式碼會傳回所有指定買方的廣告素材。

    request = realtimebidding.buyers().creatives().list(parent=BUYER_NAME)
    
    pprint.pprint(request.execute())

如要進一步瞭解如何搭配 Python 使用 Ad Exchange Buyer API,請參閱 即時出價 API 範例中的 README 檔案。

PHP

以下示範如何在 PHP 中使用即時出價 API 的基本範例。

  1. 設定依附元件

    如果您尚未安裝,請下載並安裝 Composer,然後建立包含以下內容的 composer.json

    {
      "description": "Authorized Buyers Real-Time Bidding API PHP Samples",
      "require": {
        "php": ">=7.2",
        "google/apiclient": "^2.0"
      },
      "require-dev": {
        "squizlabs/php_codesniffer": "3.*"
      },
      "type": "project",
      "homepage": "https://github.com/googleads/authorized-buyers-rtb-api-samples/tree/master/php",
      "license": "Apache-2.0",
      "authors": [
        {
          "name": "Google",
          "homepage": "https://github.com/googleads/authorized-buyers-rtb-api-samples/graphs/contributors"
        }
      ]
    }
    

    最後,請執行下列指令來安裝依附元件程式庫:

    composer install
  2. 設定用戶端

    建立 Google_Client,並將其用於將 Google_Service_RealTimeBidding 執行個體化。

    
    $client = new Google_Client();
    $client->setApplicationName('Authorized Buyers Real-time Bidding API PHP Samples');
    
    $service = new Google_Service_RealTimeBidding($client);
  3. 設定憑證

    所有呼叫 API 都需要有效的存取權杖。將用戶端設定為完成 OAuth 2.0 流程。

    
    $client->setAuthConfig($keyFileLocation);
    $client->addScope('https://www.googleapis.com/auth/realtime-bidding');
    
    if ($client->isAccessTokenExpired()) {
        $client->refreshTokenWithAssertion();
    }
  4. 執行作業

    將用戶端執行個體連線至 API 並設定 OAuth 2.0 後,您就能使用該用戶端發出 API 呼叫。以下程式碼會傳回所有指定買方的廣告素材:

    $result = $service->buyers_creatives->listBuyersCreatives($buyerName, $queryParams);
    
    print "Creatives associated with buyer account\n";
    if (empty($result['creatives'])) {
        print "No creatives found\n";
        return;
    } else {
        foreach ($result['creatives'] as $creative) {
            print_r($creative);
        }
    }

如要進一步瞭解如何搭配 PHP 使用 Ad Exchange Buyer API,請參閱 即時出價 API 範例中的 README 檔案。

.NET

以下示範如何在 C# 中使用即時出價 API。

  1. 建立新專案

    開啟 Visual Studio Code 並建立新專案。

  2. 將必要的程式庫參照新增至專案

    在專案的 *.csproj 檔案中,新增 Google.ApisGoogle.Apis.AuthGoogle.Apis.CoreGoogle.Apis.Oauth2.v2Google.Apis.RealTimeBidding.v1PackageReference 項目。例如:

    <ItemGroup>
      <PackageReference Include="Google.Apis" Version="1.57.0" />
      <PackageReference Include="Google.Apis.Auth" Version="1.57.0" />
      <PackageReference Include="Google.Apis.Core" Version="1.57.0" />
      <PackageReference Include="Google.Apis.Oauth2.v2" Version="1.57.0.1869" />
      <PackageReference Include="Google.Apis.Pubsub.v1" Version="1.57.0.2667" />
      <PackageReference Condition="!Exists('./Google.Apis.RealTimeBidding.v1.csproj')" Include="Google.Apis.RealTimeBidding.v1" Version="1.57.0.2680" />
      <PackageReference Include="log4net" Version="2.0.13" />
      <PackageReference Include="Microsoft.Extensions.Configuration" Version="3.1.4" />
      <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0">
        <PrivateAssets>all</PrivateAssets>
        <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
      </PackageReference>
      <PackageReference Include="Mono.Options" Version="6.12.0.148" />
      <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
    </ItemGroup>

    如要進一步瞭解這些依附元件,請前往:https://www.nuget.org/packages/

  3. 設定憑證

    所有傳送至 API 的呼叫都需要進行驗證;請使用上述的服務帳戶電子郵件和 JSON 檔案建立 Credential

    var credentialParameters = NewtonsoftJsonSerializer.Instance
        .Deserialize<JsonCredentialParameters>(
            System.IO.File.ReadAllText(ServiceKeyFilePath));
    
    // Create the credentials.
    var credentialInitializer = new ServiceAccountCredential.Initializer(
            credentialParameters.ClientEmail)
        {
            Scopes = new[] { RealTimeBiddingService.Scope.RealtimeBidding }
        }.FromPrivateKey(credentialParameters.PrivateKey);
    
    var oAuth2Credentials = new ServiceAccountCredential(credentialInitializer);
  4. 為即時出價 API 建構用戶端

    接著,你就能建立 RealTimeBiddingService

    var serviceInitializer = new BaseClientService.Initializer
        {
            HttpClientInitializer = oAuth2Credentials,
            ApplicationName = "FirstAPICall"
        };
    
    var realtimebidding = new RealTimeBiddingService(serviceInitializer);
  5. 執行作業

    將用戶端執行個體化為 API 執行個體化之後,您可以執行作業。以下程式碼列出與您的憑證相關聯的指定 Authorized Buyers 買方帳戶廣告素材。

    BuyersResource.CreativesResource.ListRequest request =
        realtimebidding.Buyers.Creatives.List(buyerName);
    request.View = BuyersResource.CreativesResource.ListRequest.ViewEnum.FULL;
    
    IList<Creative> creatives = request.Execute().Creatives;
    
    foreach (Creative creative in creatives)
    {
        Console.WriteLine("* Creative name: {0}", creative.Name);
    }

如要進一步瞭解如何搭配 C# 使用即時出價 API,請參閱 即時出價 API 範例中的 README 檔案。

Ruby

以下示範如何在 Ruby 中使用即時出價 API。

  1. 下載並安裝 Google API Ruby 用戶端

    如果您尚未安裝,請下載並安裝 Bundler,然後建立含有下列內容的 Gemfile

    source "https://rubygems.org"
    
    ruby "2.6.0"
    
    gem 'google-apis-pubsub_v1', '0.10.0'
    gem 'google-apis-realtimebidding_v1', '~> 0.14.0'
    

    最後,請執行下列指令來安裝依附元件程式庫:

    bundle
  2. 設定憑證

    所有傳送至 API 的呼叫都需要進行驗證;使用上述的服務帳戶電子郵件和 JSON 檔案建立憑證。

    # Create credentials using the JSON key file.
      auth_options = {
        :json_key_io => File.open(KEY_FILE, "r"),
        :scope => 'https://www.googleapis.com/auth/realtime-bidding'
      }
    
      oauth_credentials = Google::Auth::ServiceAccountCredentials.make_creds(
        options=auth_options
      )
  3. 為 AdExchangeBuyer 建立用戶端

    接著,您可以使用憑證建立已獲授權的 Ad Exchange 買方用戶端:

    # Create the service and set credentials
      realtimebidding = (
        Google::Apis::RealtimebiddingV1::RealtimeBiddingService.new
      )
      realtimebidding.authorization = oauth_credentials
      realtimebidding.authorization.fetch_access_token!
  4. 執行作業

    將用戶端執行個體化為 API 執行個體化之後,您可以執行作業。以下程式碼會傳回所有指定買方的廣告素材。

    # Call the buyers.creatives.list method to get list of creatives for given buyer.
        creatives_list = realtimebidding.list_buyer_creatives(
            BUYER_NAME, view: 'FULL')
    
        if creatives_list.creatives.any?
          puts "Found the following creatives for buyer '%s':" % BUYER_NAME
          creatives_list.creatives.each do |creative|
            puts "* Creative name: #{creative.name}"
          end
        else
          puts "No creatives were found that were associated with buyer '%s'" % BUYER_NAME
        end

如要進一步瞭解如何搭配 Ruby 使用即時出價 API,請參閱 即時出價 API 範例中的 README 檔案。

Ad Exchange 買方 API II

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.v2_x;

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 com.google.api.services.samples.adexchangebuyer.cmdline.BaseSample;
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 Access Guide">https://developers.google.com/authorized-buyers/apis/guides/v2/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.println("========================================");
      System.out.printf("Listing of Client Buyers associated with AdX Account \"%s\"%n",
          accountId);
      System.out.println("========================================");
      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 os
import sys

sys.path.insert(0, os.path.abspath('..'))

from googleapiclient.errors import HttpError
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(f'Client buyers for account ID: "{account_id}"')
    pprint.pprint(clients)
  except HttpError as e:
    print(e)


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

  try:
    service = samples_util.GetService('v2beta1')
  except IOError as ex:
    print(f'Unable to create adexchangebuyer service - {ex}')
    print('Did you specify the key file in samples_util.py?')
    sys.exit(1)

  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_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 [
        [
            'name' => 'accountId',
            'display' => 'Account ID',
            'required' => true
        ]
    ];
  }

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

  /**
   * @see BaseExample::getClientType()
   */
  public 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 Authorized Buyers " +
                "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
    raise "The following server error occured:\n%s" % e.message
  rescue Google::Apis::ClientError => e
    raise "Invalid client request:\n%s" % e.message
  rescue Google::Apis::AuthorizationError => e
    raise "Authorization error occured:\n%s" % e.message
  end
end


if __FILE__ == $0
  begin
    # Retrieve the service used to make API requests.
    service = get_service(ADEXCHANGEBUYER_V2BETA1)
  rescue ArgumentError => e
    raise 'Unable to create service, with error message: %s' % e.message
  rescue Signet::AuthorizationError => e
    raise ('Unable to create service, was the KEY_FILE in samples_util.rb ' +
           'set? Error message: %s') % e.message
  end

  # Set options and default values for fields used in this example.
  options = [
    Option.new(
      'account_id', 'The integer ID of the Authorized Buyers 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

後續步驟

  • 請參閱背景指南,進一步瞭解範例中的範例,以及開發解決方案時可用的選項。

  • 啟動用戶端程式庫並開始後,請嘗試擴充程式碼範例,以符合您的需求。

  • 請參閱所用版本的參考說明文件,進一步瞭解 API。

  • 如需相關協助,請造訪論壇

  • 如果您的應用程式預計會執行即時出價,請參閱即時出價通訊協定說明文件。

  • 查看成效提示

參與問卷調查

請填寫這份簡短的問卷調查,協助我們改善服務品質;並協助我們改善服務品質。