เริ่มต้นใช้งาน

Authorized Buyers API มี 2 ประเภทดังนี้

  • API การเสนอราคาแบบเรียลไทม์ (ล่าสุด)
  • API ผู้ซื้อของ Ad Exchange II

API เหล่านี้ช่วยให้แอปของคุณโต้ตอบกับ Authorized Buyers ได้ในกรณีต่อไปนี้

  • เข้าถึงข้อมูลบัญชีการเสนอราคาแบบเรียลไทม์
  • ส่งและจัดการครีเอทีฟโฆษณาที่อยู่ระหว่างการตรวจสอบ
  • เรียกดูเมตริกการแก้ปัญหาการเสนอราคาแบบเรียลไทม์
  • จัดการรายการผู้ใช้
  • จัดการค่ากําหนดการกําหนดเป้าหมายล่วงหน้า
  • กําหนดค่าการเข้าถึงไคลเอ็นต์สําหรับ Marketplace
  • สํารวจและจัดการข้อเสนอสําหรับดีลในตลาดกลาง

หากคุณไม่คุ้นเคยกับแนวคิดของ Authorized Buyers โปรดไปที่ศูนย์ช่วยเหลือของ Authorized Buyers แล้วลองใช้ UI

เตรียมพร้อมสําหรับการให้สิทธิ์

ทําตามขั้นตอนต่อไปนี้เพื่อเตรียมการตรวจสอบสิทธิ์โดยใช้ OAuth 2.0 API รองรับข้อมูลเข้าสู่ระบบหลายประเภท ในตัวอย่างนี้เราจะใช้บัญชีบริการ

  1. ไปที่หน้า API ที่เปิดใช้คอนโซล Google API

  2. เลือกโปรเจ็กต์หรือสร้างโปรเจ็กต์จากเมนูแบบเลื่อนลงของโปรเจ็กต์

  3. ในรายการ API ที่เปิดใช้ ตรวจดูว่า Ad Exchange Buyer API อยู่ในรายการ หากไม่อยู่ในรายการ ให้คลิกแท็บ Google API ค้นหาและเลือก API ผู้ซื้อของ Ad Exchange แล้วคลิกเปิดใช้ API

  4. จากนั้นเลือกข้อมูลเข้าสู่ระบบในแถบด้านข้างทางซ้าย

  5. เลือกสร้างข้อมูลเข้าสู่ระบบแบบเลื่อนลง แล้วเลือกคีย์บัญชีบริการ

  6. ในรายการแบบเลื่อนลงของบัญชีบริการ ให้เลือกบัญชีบริการใหม่

  7. ป้อนชื่อสําหรับบัญชีบริการ รหัสบัญชีบริการจะสร้างขึ้นโดยอัตโนมัติจากชื่อและโปรเจ็กต์

  8. ระบุรหัสบัญชีบริการ: คุณต้องใช้รหัสดังกล่าวเพื่อเข้าถึงบัญชีบริการใหม่ใน UI ของ Authorized Buyers ในขั้นตอนที่ 11

  9. เลือกประเภทคีย์ เป็นไฟล์ JSON ที่แนะนําหรือ P12 หากจําเป็นต้องใช้ความเข้ากันได้แบบย้อนหลังกับโค้ดที่ใช้รูปแบบ P12

  10. คลิกสร้าง ไฟล์ JSON หรือ P12 ที่มีคู่คีย์สาธารณะ/ส่วนตัวของบัญชีจะบันทึกอยู่ในโฟลเดอร์ "ดาวน์โหลด" ของคุณ แล้วเก็บไฟล์ JSON หรือ P12 ที่สร้างขึ้น ไว้ในที่ปลอดภัย

  11. คุณจะต้องให้สิทธิ์เข้าถึงบัญชีบริการใน UI ของ Authorized Buyers เพื่อให้บัญชีบริการทํางาน เลือก การตั้งค่า > การตั้งค่าบัญชี แล้วเลือก การจัดการผู้ใช้ > ผู้ใช้บัญชี และคลิก +บัญชีบริการ ป้อนรหัสบัญชีบริการที่ระบุไว้ข้างต้นในขั้นตอนที่ 8 การดําเนินการนี้จะสร้างผู้ใช้ใหม่ที่มีบทบาทบัญชีบริการ

ขอบเขต OAuth

เมื่อเข้าสู่ขั้นตอนการให้สิทธิ์ OAuth 2.0 แอปพลิเคชันของคุณสามารถระบุขอบเขตเพื่อระบุว่าต้องการเข้าถึงฟีเจอร์บางอย่างใน Google API สําหรับบัญชี Google ที่ระบุ หากต้องการเข้าถึง API ของ Authorized Buyers ในนามของบัญชี Authorized Buyers คุณต้องระบุขอบเขตที่เชื่อมโยงกับ 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 สิทธิ์การอ่าน/เขียน

API ผู้ซื้อของ Ad Exchange 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

  1. สร้างโปรเจ็กต์ Maven

    เปิด pom.xml และเพิ่มทรัพยากร Dependency เหล่านี้:

    <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 ทั้งหมดจะต้องมีการตรวจสอบสิทธิ์ สร้าง Credential โดยใช้คีย์ JSON ของบัญชีบริการที่กล่าวถึงข้างต้น

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

ดูข้อมูลโดยละเอียดเกี่ยวกับการใช้ Real-time Bidding API กับ Java ได้จากไฟล์ README ในตัวอย่าง API การเสนอราคาแบบเรียลไทม์

Python

ต่อไปนี้คือตัวอย่างพื้นฐานที่แสดงวิธีใช้ API การเสนอราคาแบบเรียลไทม์กับ Python

  1. ดาวน์โหลดและติดตั้งไคลเอ็นต์ Google API Python

    ตัวอย่างการใช้ PIP

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

  2. ตั้งค่าข้อมูลเข้าสู่ระบบ

    การเรียก API ทั้งหมดจะต้องมีการตรวจสอบสิทธิ์ สร้างอินสแตนซ์ service_account.Credentials โดยใช้ไฟล์คีย์ JSON ของบัญชีบริการที่กล่าวถึงข้างต้น

      credentials = service_account.Credentials.from_service_account_file(
          KEY_FILE, scopes=[SCOPE])
  3. สร้างไคลเอ็นต์สําหรับ API การเสนอราคาแบบเรียลไทม์

    จากนั้นคุณจะสร้างไคลเอ็นต์ API การเสนอราคาแบบเรียลไทม์ได้โดยใช้อินสแตนซ์ service_account.Credentials ที่ได้รับอนุญาต

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

  4. ดําเนินการ

    หลังจากที่เริ่มต้นไคลเอ็นต์ให้เชื่อมต่อกับ API แล้ว คุณจะดําเนินการบางอย่างได้ โค้ดต่อไปนี้จะแสดงครีเอทีฟโฆษณาของผู้ซื้อทุกคน

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

หากต้องการข้อมูลโดยละเอียดเกี่ยวกับการใช้ Ad Exchange Buyer API กับ Python โปรดดูไฟล์ README ในตัวอย่าง API การเสนอราคาแบบเรียลไทม์

PHP

ต่อไปนี้คือตัวอย่างพื้นฐานที่แสดงวิธีใช้ API การเสนอราคาแบบเรียลไทม์กับ PHP

  1. ตั้งค่าทรัพยากร Dependency

    หากยังไม่ได้ติดตั้ง ให้ดาวน์โหลดและติดตั้งคอมโพสเซอร์ จากนั้นสร้าง 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"
        }
      ]
    }
    

    สุดท้าย ให้เรียกใช้คําสั่งต่อไปนี้เพื่อติดตั้งไลบรารีทรัพยากร Dependency

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

หากต้องการข้อมูลโดยละเอียดเกี่ยวกับการใช้ Ad Exchange Buyer API กับ PHP โปรดดูไฟล์ README ในตัวอย่าง API การเสนอราคาแบบเรียลไทม์

.NET

ต่อไปนี้คือตัวอย่างพื้นฐานที่แสดงวิธีใช้ API การเสนอราคาแบบเรียลไทม์กับ C#

  1. สร้างโปรเจ็กต์ใหม่

    เปิดโค้ด Visual Studio และสร้างโปรเจ็กต์ใหม่

  2. เพิ่มการอ้างอิงไลบรารีที่จําเป็นลงในโปรเจ็กต์

    เพิ่มไฟล์ PackageReference สําหรับ Google.Apis, Google.Apis.Auth, Google.Apis.Core, Google.Apis.Oauth2.v2 และ Google.Apis.RealTimeBidding.v1 ในไฟล์ *.csEMM ของโปรเจ็กต์ ตัวอย่างอาจมีลักษณะดังนี้

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

    ดูข้อมูลเพิ่มเติมเกี่ยวกับทรัพยากร Dependency เหล่านี้ได้ที่ https://www.nuget.org/packages/

  3. ตั้งค่าข้อมูลเข้าสู่ระบบ

    การเรียก API ทั้งหมดจําเป็นต้องมีการตรวจสอบสิทธิ์ โดยให้สร้าง Credential โดยใช้อีเมลบัญชีบริการและไฟล์ JSON ที่กล่าวถึงข้างต้น

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

ดูข้อมูลโดยละเอียดเกี่ยวกับการใช้ Real-time Bidding API กับ C# ได้ที่ไฟล์ README ในตัวอย่าง API การเสนอราคาแบบเรียลไทม์

Ruby

ต่อไปนี้คือตัวอย่างพื้นฐานที่แสดงวิธีใช้ API การเสนอราคาแบบเรียลไทม์กับ Ruby

  1. ดาวน์โหลดและติดตั้งไคลเอ็นต์ API ของ Google API

    หากยังไม่ได้ติดตั้ง ให้ดาวน์โหลดและติดตั้ง 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'
    

    สุดท้าย ให้เรียกใช้คําสั่งต่อไปนี้เพื่อติดตั้งไลบรารีทรัพยากร Dependency

    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 Buyer ที่ได้รับอนุญาตโดยใช้ข้อมูลเข้าสู่ระบบได้โดยทําดังนี้

    # 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

ดูข้อมูลโดยละเอียดเพิ่มเติมเกี่ยวกับการใช้ Real-time Bidding API กับ Ruby ได้ที่ไฟล์ README ในตัวอย่าง Real-time Bidding API

API ผู้ซื้อของ Ad Exchange 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

  • หากต้องการความช่วยเหลือ โปรดไปที่ฟอรัม

  • หากต้องการให้แอปพลิเคชันใช้การเสนอราคาแบบเรียลไทม์ โปรดอ่านเอกสารโปรโตคอล RTB

  • อ่านเคล็ดลับด้านประสิทธิภาพ

ทำแบบสำรวจ

ช่วยเราปรับปรุงเอกสารนี้ บอกให้เราทราบถึงสิ่งที่ได้ผลและสิ่งที่เราพลาดไปโดยการกรอกแบบสํารวจ