시작하기

승인됨 구매자:

• Marketplace API 거래, 입찰 패키지, 고객 액세스를 관리하세요.
• 실시간 입찰 API: QPS를 포함한 입찰 관리 할당량, 타겟팅, 광고 소재가 있습니다.
• (지원 중단됨)Ad Exchange 구매자 API II: 이 API는 지원 중단되었습니다. 관련 리소스를 제외한 모든 리소스는 RTB 문제 해결 서비스가 종료되었습니다.

다음은 Authorized Buyers를 사용하여 완료할 수 있는 작업의 예입니다. API:

• 실시간 입찰 계정 정보 액세스
• 검토 중인 광고 소재를 제출하고 관리합니다.
• 실시간 입찰 문제 해결 측정항목을 가져옵니다.
• Authorized Buyers 사용자 관리 목록을 참조하세요.
• 사전 타겟팅 구성을 관리합니다.
• Marketplace에 대한 클라이언트 액세스를 구성합니다.
• 마켓플레이스에서 거래 제안서를 탐색하고 관리할 수 있습니다.

Authorized Buyers에 대해 잘 모르는 경우 Authorized Buyers 도움말 센터 및 사용자 인터페이스 를 참조하세요.

빠른 링크

• 광고 소재 관리
• 거래 관리
• Ad Exchange 구매자 II API에서 이전하기

인증 설정

Google API는 다음을 위해 OAuth 2.0 프로토콜을 사용합니다. 사용할 수 있습니다 다음에 대한 인증을 설정하는 방법은 다음과 같습니다. OAuth 2.0을 사용하는 실시간 입찰 API.

이 예에서는 서비스 계정을 선택합니다. 자세한 내용은 Google Cloud Identity Access Management 문서를 참조하세요.

1. Google API 콘솔 지원 API로 이동 페이지를 참조하세요.

2. 프로젝트 드롭다운에서 프로젝트를 선택하거나 새 프로젝트를 만듭니다.

   참고: 여러 사람에게 관리자 권한을 부여하는 것이 좋습니다. 액세스 프로젝트에 대한 액세스 권한을 잃지 마세요.

3. 사용 설정된 API 목록에 Real-time Auction API가 표시되어 있는지 확인합니다. 만약 API가 목록에 없으면 Google API 탭을 클릭하고 실시간 입찰 API를 클릭하고 API 사용 설정을 클릭합니다.

4. 그런 다음 왼쪽 사이드바에서 사용자 인증 정보를 선택합니다.

5. 사용자 인증 정보 만들기 드롭다운을 선택한 다음 서비스 계정을 선택합니다. 키를 참고하세요.

6. 서비스 계정 드롭다운에서 새 서비스 계정을 선택합니다.

7. 서비스 계정의 이름을 입력합니다. 서비스 계정 ID는 다음과 같습니다. 프로젝트 이름 및 프로젝트 이름에서 자동으로 생성됩니다

8. 서비스 계정 ID를 기록해 둡니다. 이 ID는 새 서비스에 대한 액세스 권한을 부여하는 데 필요합니다. 계정에 연결할 수 있습니다.

9. 키 유형으로 권장되는 JSON 파일을 선택합니다.

10. 만들기를 클릭합니다. 계정의 공개 키/비공개 키 쌍이 포함된 JSON 파일 다운로드 폴더에 저장됩니다. 생성된 JSON 파일을 안전하게 보관하세요

11. Authorized Buyers UI를 사용해야 합니다. 설정 > 계정 설정을 클릭한 다음 사용자 관리 > 계정 사용자 +서비스 계정을 클릭합니다. 위에서 기록한 서비스 계정 ID를 입력합니다. 8단계로 이동합니다. 이렇게 하면 서비스 계정 역할이 있는 신규 사용자가 생성됩니다.

여러 사용자에게 클라우드 프로젝트에 대한 관리 액세스 권한이 있는지 확인하세요. 권한을 변경해야 합니다.

API 액세스 요청

OAuth 2.0 인증 흐름을 단계별로 실행하면 애플리케이션에서 다음과 같은 작업을 할 수 있습니다. 범위를 지정하여 특정 항목에 대한 액세스 권한을 요청합니다. 기능을 위임할 수 있습니다. 다음 범위를 사용하여 얻습니다. 광고주를 대신하여 Authorized Buyers API에 대한 Authorized Buyers 계정:

• Marketplace API https://www.googleapis.com/auth/authorized-buyers-marketplace
• 실시간 입찰 API: https://www.googleapis.com/auth/realtime-bidding
• Ad Exchange 구매자 API II: https://www.googleapis.com/auth/adexchange.buyer

API 호출

다음은 지원되는 언어로 시작하는 데 사용할 수 있는 몇 가지 샘플입니다.

마켓플레이스 API

자바

/*
 * 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와 함께 Real-time Bidding 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에 연결할 클라이언트를 인스턴스화한 후에는 작업을 수행합니다. 다음 코드는 지정된 Buyer의 있습니다.

       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);
       }
    creatives.*?BUYER_NAME\);\s*}">FirstApiRequest.java

Java에서 Real-time Bidding API를 사용하는 방법에 대한 자세한 내용은 다음을 참조하세요. README를 참조하세요. 파일 Real-time Bidding API 예시에 나와 있습니다.

Python

다음은 Python으로 실시간 입찰 API를 사용하는 방법을 보여주는 기본적인 예입니다.

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용 클라이언트 구축

   그런 다음 승인된 service_account.Credentials 인스턴스:

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

4. 작업 실행

   API에 연결할 클라이언트를 인스턴스화한 후에는 작업을 수행합니다. 다음 코드는 지정된 Buyer의 있습니다.

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

Python에서 Ad Exchange 구매자 API를 사용하는 방법에 대해 자세히 알아보려면 README를 참조하세요. 파일 Real-time Bidding API 예시에 나와 있습니다.

PHP

다음은 실시간 입찰 API를 PHP

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-s>etApplicationName(A'uthorized Buyers Real-time Bidding API PHP Samples)';
   
   $service = new Google_Service_RealTimeBidding($client);

3. 사용자 인증 정보 설정

   모든 API 호출에는 유효한 액세스 토큰이 필요합니다. 다음과 같이 클라이언트를 구성합니다. OAuth 2.0 흐름을 통해 확인할 수 있습니다

   $client-s>etAuthConfig($keyFileLocation);
   $client-a>ddScope(h'ttps://www.googleapis.com/auth/realtime-bidding)';
   
   if ($client-i>sAccessTokenExpired()) {
       $client-r>efreshTokenWithAssertion();
   }

4. 작업 실행

   API에 연결할 클라이언트를 인스턴스화하고 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);
       }
   }
   FirstApiRequest.php

PHP에서 Ad Exchange 구매자 API를 사용하는 방법에 대해 자세히 알아보려면 README를 참조하세요. 파일 Real-time Bidding API 예시에 나와 있습니다.

.NET

다음은 C#으로 실시간 입찰 API를 사용하는 방법을 보여주는 기본적인 예입니다.

1. 새 프로젝트 생성

   Visual Studio Code를 열고 새 프로젝트를 만듭니다.

2. 프로젝트에 필수 라이브러리 참조 추가

   프로젝트의 *.csproj 파일에 Google.Apis에 대한 PackageReference 항목, Google.Apis.Auth님, Google.Apis.Core님, Google.Apis.Oauth2.v2 및 Google.Apis.RealTimeBidding.v1 예를 들어, 다음과 같습니다.

   <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 호출에는 인증이 필요합니다. 만들기 Credential 서비스 계정 이메일 및 JSON 파일을 사용하여 Google Cloud 리소스에 연결할 수 있습니다

   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);
   }
   FirstApiRequest.cs

C#과 함께 Real-time Bidding API를 사용하는 방법에 대한 자세한 내용은 다음을 참조하세요. README 파일() 실시간 입찰 API 예시.

Ruby

다음은 실시간 입찰 API를 Ruby

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를 위한 클라이언트 만들기

   그런 다음 사용자 인증 정보:

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

4. 작업 실행

   API에 연결할 클라이언트를 인스턴스화한 후에는 작업을 수행합니다. 다음 코드는 지정된 Buyer의 있습니다.

   # 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
   first_api_request.rb

Ruby에서 실시간 입찰 API를 사용하는 방법에 대한 자세한 내용은 다음을 참조하세요. README를 참조하세요. 파일() 실시간 입찰 API 예시.

Ad Exchange 구매자 API II

자바

/*
 * Copyright (c) 2017 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.AbsoluteDateRange;
import com.google.api.services.adexchangebuyer2.v2beta1.model.Client;
import com.google.api.services.adexchangebuyer2.v2beta1.model.Date;
import com.google.api.services.adexchangebuyer2.v2beta1.model.FilterSet;
import com.google.api.services.adexchangebuyer2.v2beta1.model.RealtimeTimeRange;
import com.google.api.services.adexchangebuyer2.v2beta1.model.RelativeDateRange;
import com.google.api.services.samples.adexchangebuyer.cmdline.BaseSample;
import java.io.IOException;
import java.util.List;

/**
 * This sample illustrates how to retrieve all Bidder-level Filter Sets.
 */
public class GetAllBidderLevelFilterSets extends BaseSample {
  @Override
  public ClientType getClientType() {
    return ClientType.ADEXCHANGEBUYERII;
  }

  @Override
  public String getName() {
    return "Get All Bidder-level Filter Sets.";
  }

  @Override
  public String getDescription() {
    return "Lists Filter Sets associated with the given Bidder.";
  }

  @Override
  public void execute(AbstractGoogleJsonClient client) throws IOException {
    AdExchangeBuyerII adXClient = (AdExchangeBuyerII) client;
    String bidderResourceId = getStringInput("bidderResourceId", "Enter the Bidder's resource ID");
    String ownerName = String.format("bidders/%s", bidderResourceId);
    List<FilterSet> allFilterSets = adXClient.bidders().filterSets().list(ownerName).execute()
        .getFilterSets();

    if (allFilterSets != null && allFilterSets.size() > 0) {
      System.out.println("========================================");
      System.out.printf("Listing of Filter Sets associated with Bidder \"%s\"%n", ownerName);
      System.out.println("========================================");
      for (FilterSet filterSet : allFilterSets) {
        System.out.printf("* Filter Set name: %s%n", filterSet.getName());
        AbsoluteDateRange absDateRange = filterSet.getAbsoluteDateRange();
        if(absDateRange != null) {
          System.out.println("AbsoluteDateRange");
          System.out.printf("\tStart date: %s%n",
              convertDateToString(absDateRange.getStartDate()));
          System.out.printf("\tEnd date: %s%n",
              convertDateToString(absDateRange.getEndDate()));
        }
        RelativeDateRange relDateRange = filterSet.getRelativeDateRange();
        if(relDateRange != null) {
          Integer offset = relDateRange.getOffsetDays();
          System.out.println("RelativeDateRange");
          System.out.printf("\tOffset days: %s%n", offset != null ? offset : 0);
          System.out.printf("\tDuration days: %s%n", relDateRange.getDurationDays());
        }
        RealtimeTimeRange rtTimeRange = filterSet.getRealtimeTimeRange();
        if(rtTimeRange != null) {
          System.out.println("RealtimeTimeRange");
          System.out.printf("\tStart timestamp: %s%n", rtTimeRange.getStartTimestamp());
        }
        String timeSeriesGranularity = filterSet.getTimeSeriesGranularity();
        if(timeSeriesGranularity != null) {
          System.out.printf("Time series granularity: %s%n", timeSeriesGranularity);
        }
        String format = filterSet.getFormat();
        if(format != null) {
          System.out.printf("\tFormat: %s%n", format);
        }
        String environment = filterSet.getEnvironment();
        if(environment != null) {
          System.out.printf("Environment: %s%n", environment);
        }
        List<String> platforms = filterSet.getPlatforms();
        if(platforms != null) {
          System.out.println("Platforms:");
          for(String platform : platforms) {
            System.out.printf("\t%s%n", platform);
          }
        }
        List<Integer> sellerNetworkIds = filterSet.getSellerNetworkIds();
        if(filterSet.getSellerNetworkIds() != null) {
          System.out.println("Seller network IDS:");
          for(Integer sellerNetworkId : sellerNetworkIds) {
            System.out.printf("\t%d%n", sellerNetworkId);
          }
        }
      }
    } else {
      System.out.printf("No Filter Sets were found associated with Bidder \"%s\"%n", ownerName);
    }
  }

  private String convertDateToString(Date date) {
    return String.format("%d%02d%02d", date.getYear(), date.getMonth(), date.getDay());
  }
}

Python

#!/usr/bin/python
#
# Copyright 2017 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 bidder-level filter sets."""


import argparse
import os
import pprint
import sys

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

from googleapiclient.errors import HttpError
import samples_util


_OWNER_NAME_TEMPLATE = 'bidders/{bidders_resource_id}'

DEFAULT_BIDDER_RESOURCE_ID = 'ENTER_BIDDER_RESOURCE_ID_HERE'


def main(ad_exchange_buyer, owner_name):
  try:
    # Construct and execute the request.
    filter_sets = ad_exchange_buyer.bidders().filterSets().list(
        ownerName=owner_name).execute()
    print(f'Listing FilterSets for bidder: "{owner_name}".')
    pprint.pprint(filter_sets)
  except HttpError as e:
    print(e)


if __name__ == '__main__':
  parser = argparse.ArgumentParser(
      description='Creates a bidder-level filter set with the specified options'
  )
  # Required fields.
  parser.add_argument(
      '-b', '--bidder_resource_id', default=DEFAULT_BIDDER_RESOURCE_ID,
      help=('The resource ID of the bidders resource for which the filter '
            'sets were created. This will be used to construct the ownerName '
            'used as a path parameter for filter set requests. For additional '
            'information on how to configure the ownerName path parameter, '
            'see: https://developers.google.com/authorized-buyers/apis/'
            'reference/rest/v2beta1/bidders.filterSets/list'
            '#body.PATH_PARAMETERS.owner_name'))

  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, _OWNER_NAME_TEMPLATE.format(
           bidders_resource_id=args.bidder_resource_id))

PHP

<?php
/**
 * Copyright 2017 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 Bidder-level Filter Sets.
 */
class ListBidderLevelFilterSets extends BaseExample {

  /**
   * @see BaseExample::getInputParameters()
   */
  protected function getInputParameters() {
    return [
        [
            'name' => 'bidderResourceId',
            'display' => 'Bidder Resource ID',
            'required' => true
        ]
    ];
  }

  /**
   * @see BaseExample::run()
   */
  public function run() {
    $values = $this->formValues;
    $ownerName = sprintf(
        'bidders/%s',
        $values['bidderResourceId']
    );
    $result = $this->service->bidders_filterSets
        ->listBiddersFilterSets($ownerName);
    print sprintf(
        '<h2>Listing Bidder-level Filter Sets for ownerName "%s"</h2>',
         $ownerName
    );
    if (empty($result['filterSets'])) {
      print '<p>No Bidder-level Filter Sets found.</p>';
    } else {
      foreach ($result['filterSets'] as $filterSets) {
        $this->printResult($filterSets);
      }
    }
  }

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

  /**
   * @see BaseExample::getName()
   */
  public function getName() {
    return 'RTB Troubleshooting: List Bidder-level Filter Sets';
  }
}

.NET

/* Copyright 2017, Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the L"icense)";
 * 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 A"S 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;
using System.Collections.Generic;

namespace Google.Apis.AdExchangeBuyer.Examples.v2_x
{
    /// s<ummary<>/span>
    /// Retrieves the bidder-level filter sets for the given bidder resource ID.
    /// /<summary<>/span>
    public class ListBidderLevelFilterSets : ExampleBase
    {
        /// s<ummary<>/span>
        /// Main method, to run this code example as a standalone application.
        /// /<summary<>/span>
        /// p<aram name=a"rgsT">he command line arguments/<param<>/span>
        public static void Main(string[] args)
        {
            AdExchangeBuyerIIService service = Utilities.GetV2Service();
            ExampleBase example = new ListBidderLevelFilterSets();
            Console.WriteLine(example.Description);

            example.Run(service);
        }

        /// s<ummary<>/span>
        /// Returns a description about the code example.
        /// /<summary<>/span>
        public override string Description
        {
            get { return T"his code example lists all bidder-level filter sets for the given  "+
                    b"idder resource ID.;" }
        }

        /// s<ummary<>/span>
        /// Runs the code example.
        /// /<summary<>/span>
        /// p<aram name=s"erviceA">n authenticated AdExchangeBuyerIIService/<param<>/span>
        public override void Run(BaseClientService service)
        {
            AdExchangeBuyerIIService adXService = (AdExchangeBuyerIIService)service;
            string bidderResourceId = I"NSERT_BIDDER_RESOURCE_ID_HERE;"
            string ownerName = String.Format(b"idders/{0}," bidderResourceId);

            ListFilterSetsResponse response = adXService.Bidders.FilterSets.List(ownerName)
                .Execute();

            Console.WriteLine(="=======================================\n)";
            Console.WriteLine(L"isting of filter sets associated with owner name \{"0}\,""
                ownerName);
            Console.WriteLine(="=======================================\n)";

            if (response.FilterSets.Count == 0)
            {
                Console.WriteLine(N"o filter sets found.)";
            } else
            {
                foreach (FilterSet filterSet in response.FilterSets)
                {
                    Console.WriteLine(*" Name: {0}," filterSet.Name);
                    AbsoluteDateRange absDateRange = filterSet.AbsoluteDateRange;
                    if (absDateRange != null)
                    {
                        Console.WriteLine(\"tAbsoluteDateRange:)";
                        Date startDate = absDateRange.StartDate;
                        Console.WriteLine(\"t\tStartDate:)";
                        Console.WriteLine(\"t\t\tYear: {0}," startDate.Year);
                        Console.WriteLine(\"t\t\tMonth: {0}," startDate.Month);
                        Console.WriteLine(\"t\t\tDay: {0}," startDate.Day);
                        Date endDate = absDateRange.EndDate;
                        Console.WriteLine(\"t\tEndDate:)";
                        Console.WriteLine(\"t\t\tYear: {0}," endDate.Year);
                        Console.WriteLine(\"t\t\tMonth: {0}," endDate.Month);
                        Console.WriteLine(\"t\t\tDay: {0}," endDate.Day);
                    }
                    RelativeDateRange relDateRange = filterSet.RelativeDateRange;
                    if (relDateRange != null)
                    {
                        Console.WriteLine(\"tRelativeDateRange:)";
                        Console.WriteLine(\"t\tOffsetDays: {0}," relDateRange.OffsetDays);
                        Console.WriteLine(\"t\tDurationDays: {0}," relDateRange.DurationDays);
                    }
                    RealtimeTimeRange rtTimeRange = filterSet.RealtimeTimeRange;
                    if (rtTimeRange != null)
                    {
                        Console.WriteLine(\"tRealtimeTimeRange:)";
                        Console.WriteLine(\"t\tStartTimestamp: {0}," rtTimeRange.StartTimestamp);
                    }
                    String timeSeriesGranularity = filterSet.TimeSeriesGranularity;
                    if (timeSeriesGranularity != null)
                    {
                        Console.WriteLine(\"tTimeSeriesGranularity: {0}," timeSeriesGranularity);
                    }
                    IListS<tring >formats = filterSet.Formats;
                    if (formats != null)
                    {
                        Console.WriteLine(\"tFormats:)";
                        foreach (string format in formats)
                        {
                            Console.WriteLine(\"t\t{0}," format);
                        }
                    }
                    String environment = filterSet.Environment;
                    if (environment != null)
                    {
                        Console.WriteLine(\"tEnvironment: {0}," environment);
                    }
                    ILists<tring >platforms = filterSet.Platforms;
                    if (platforms != null)
                    {
                        Console.WriteLine(\"tPlatforms:)";
                        foreach (string platform in platforms)
                        {
                            Console.WriteLine(\"t\t{0}," platform);
                        }
                    }
                    IListi<nt? >sellerNetworkIds = filterSet.SellerNetworkIds;
                    if (sellerNetworkIds != null)
                    {
                        Console.WriteLine(\"tSellerNetworkIds:)";
                        foreach (int? sellerNetworkId in sellerNetworkIds)
                        {
                            Console.WriteLine(\"t\t{0}," sellerNetworkId);
                        }
                    }
                }
            }
        }

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

Ruby

#!/usr/bin/env ruby
# Encoding: utf-8
#
# Copyright:: Copyright 2017, 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 filter sets for a given bidder.
#
# Tags: Bidders.FilterSets.list

require 'optparse'

require_relative '../samples_util'


def list_bidder_level_filter_sets(ad_exchange_buyer, owner_name, page_size)
  begin
    response = ad_exchange_buyer.list_bidder_filter_sets(
        owner_name, page_size: page_size
    )

    unless response.filter_sets.nil?
      puts 'Found the following filter sets for bidder %s:' % owner_name
      response.filter_sets.each do |filter_set|
        puts '* Filter set name: %s' % filter_set.name
        if !filter_set.absolute_date_range.nil?
          abs_date_range = filter_set.absolute_date_range
          start_date = abs_date_range.start_date
          end_date = abs_date_range.end_date
          puts "\tAbsolute date range:"
          puts "\t\tStart date: %s-%s-%s" % [start_date.year, start_date.month,
              start_date.day]
          puts "\t\tEnd date: %s-%s-%s" % [end_date.year, end_date.month,
              end_date.day]
        end
        unless filter_set.realtime_time_range.nil?
          realtime_time_range = filter_set.realtime_time_range
          puts "\tRealtime time range:"
          puts "\t\tStart timestamp: %s" % realtime_time_range.start_timestamp
        end
        unless filter_set.relative_date_range.nil?
          relative_date_range = filter_set.relative_date_range
          puts "\tRelative date range:"
          puts "\t\tOffset days: %s" % relative_date_range.offset_days
          puts "\t\tDuration days: %s" % relative_date_range.duration_days
        end
        unless filter_set.time_series_granularity.nil?
          puts "\tTime series granularity: %s" %
              filter_set.time_series_granularity
        end
        unless filter_set.format.nil?
          puts "\tFormat: %s" % filter_set.format
        end
        unless filter_set.environment.nil?
          puts "\tEnvironment: %s" % filter_set.environment
        end
        unless filter_set.platforms.nil?
          puts "\tPlatforms: %s" % filter_set.platforms.inspect
        end
        unless filter_set.seller_network_ids.nil?
          puts "\tSeller network IDs: %s" %
              filter_set.seller_network_ids.inspect
        end
      end
    else
      puts 'No filter sets found for bidder %s.' % owner_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
    # 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(
      'bidder_resource_id',
      ('The resource ID of the bidders resource for which the filter ' +
       'sets were created. This will be used to construct the ownerName ' +
       'used as a path parameter for filter set requests. For additional ' +
       'information on how to configure the ownerName path parameter, ' +
       'see: https://developers.google.com/authorized-buyers/apis/reference/' +
       'rest/v2beta1/bidders.filterSets/list#body.PATH_PARAMETERS.owner_name'),
      :short_alias => 'b', :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)

  owner_name = 'bidders/%s' % opts['bidder_resource_id']

  list_bidder_level_filter_sets(service, owner_name, opts['max_page_size'])
end

다음 단계

• 백그라운드 가이드를 읽고 샘플 및 개발 과정 개발에 사용할 수 있는 옵션에 대해 솔루션을 제공합니다

• 클라이언트 라이브러리를 설정한 후 필요에 맞게 코드 샘플을 확장할 수 있습니다

• 참조 문서에서 API에 대해 자세히 알아보세요.

• 도움이 필요한 경우 포럼을 방문하세요.

• 애플리케이션에서 실시간 입찰을 실행할 것으로 예상되는 경우 RTB 프로토콜 문서를 참조하세요.

• 실적 관련 팁을 살펴봅니다.

설문조사 참여

효과가 있었던 부분과 놓친 부분을 알려 주세요. 문서 개선에 도움이 됩니다. 간단한 양식을 작성하고 설문조사를 참조하세요.