Comenzar

Existen tres APIs que puedes usar para interactuar de manera programática con las APIs de Compradores:

• API de Marketplace: Administrar acuerdos, paquetes de subasta y acceso de clientes
• API de Real-time Bidding: Administrar las ofertas, incluidas las QPS las cuotas, segmentación, y las creatividades.
• (Obsoleto)API de Ad Exchange Buyer II: Esta API está obsoleta. Todos los recursos, excepto los relacionados con Solución de problemas de RTB se han descontinuado.

Estos son algunos ejemplos de tareas que puede completar con Authorized Buyers APIs:

• Acceder a la información de la cuenta de ofertas en tiempo real
• Envía y administra creatividades en proceso de revisión.
• Recuperar métricas de la solución de problemas de ofertas en tiempo real
• Administrar usuario de Authorized Buyers listas.
• Administra los parámetros de configuración de la segmentación previa.
• Configura el acceso de cliente para Marketplace.
• Descubre y administra propuestas de acuerdos en Marketplace.

Si no conoces Authorized Buyers, consulta el artículo Ayuda de Authorized Buyers. central y IU para obtener más información.

Vínculos rápidos

• Cómo administrar creatividades
• Cómo administrar acuerdos
• Cómo migrar desde la API de Ad Exchange Buyer II

Configura la autenticación

Las APIs de Google usan el protocolo OAuth 2.0 para autenticación y autorización. Aquí te mostramos cómo configurar la autenticación para API de Realtime Bidding con OAuth 2.0.

En este ejemplo, se usa una configuración cuenta de servicio. Consulta la página Identity & Access Management para conocer más detalles sobre el control de acceso.

1. Ve a las APIs habilitadas de la Consola de APIs de Google. .

2. En el menú desplegable de proyectos, selecciona un proyecto o crea uno nuevo.

   Nota: Recomendamos que otorgues a varias personas Administrador acceso al proyecto para no perder el acceso.

3. En la lista de APIs habilitadas, asegúrate de que se incluya la API de Real-time Bidding. Si no aparece en la lista, haz clic en la pestaña de las APIs de Google, busca y selecciona la API de Ofertas en tiempo real y haga clic en Habilitar API.

4. Luego, en la barra lateral izquierda, selecciona Credenciales.

5. Selecciona el menú desplegable Crear credenciales y, luego, elige Cuenta de servicio. .

6. En el menú desplegable Cuenta de servicio, elige Nueva cuenta de servicio.

7. Ingresa un Nombre para la cuenta de servicio. El ID de la cuenta de servicio es generados automáticamente a partir del nombre y el nombre del proyecto.

8. Anota el ID de la cuenta de servicio: lo necesitas para otorgar acceso al nuevo servicio. en la IU de Authorized Buyers que se indican en el paso 11.

9. Elige el archivo JSON recomendado como el Tipo de clave.

10. Haz clic en Crear. El archivo JSON con el par de claves pública/privada de la cuenta se guarda en tu carpeta Descargas. Mantener el archivo JSON generado en una un lugar seguro.

11. Debes otorgar acceso a la cuenta de servicio en la página Authorized Buyers IU para que funcione. Selecciona Configuración > Configuración de la cuenta y, luego, Administración de usuarios > Usuarios de la cuenta Haz clic en +Cuenta de servicio. Ingresa el ID de la cuenta de servicio que anotaste antes Paso 8: Esto crea un usuario nuevo con el rol de cuenta de servicio.

Asegúrate de que varias personas tengan acceso de administrador al proyecto de la nube, en caso de que necesitas cambiar los permisos.

Solicita acceso a la API

Cuando recorres el flujo de autorización de OAuth 2.0, tu aplicación puede especificar permisos para solicitar acceso a ciertos funciones en nombre de otras Cuentas de Google. Usa los siguientes alcances para obtener acceso de lectura/escritura a cualquiera de las APIs de Authorized Buyers en nombre de un Cuenta de Authorized Buyers:

• API de Marketplace: https://www.googleapis.com/auth/authorized-buyers-marketplace
• API de Real-time Bidding: https://www.googleapis.com/auth/realtime-bidding
• API de Ad Exchange Buyer II: https://www.googleapis.com/auth/adexchange.buyer

Realiza una llamada a la API

Aquí encontrarás algunos ejemplos que puedes usar para comenzar en los lenguajes admitidos:

API de Marketplace

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

Rita

#!/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

API de Real‑time Bidding

Java

A continuación, se incluye un ejemplo básico que muestra cómo usar la API de Real-time Bidding con Java.

1. Crea un proyecto de Maven

   Abre el archivo pom.xml y agrega estas dependencias:

   <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. Configura tus credenciales

   Todas las llamadas a la API requieren autenticación. crear un Credential usando el archivo de claves JSON de la cuenta de servicio analizado arriba.

   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. Crea un cliente para la API de Real-time Bidding

   Luego, puedes crear tu cliente de la API de Real-time Bidding con Builder. diseño:

   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. Cómo realizar una operación

   Después de crear una instancia de un cliente para conectarse a la API, puedes realizar una operación. El siguiente código devuelve todos los datos de un comprador creatividades.

       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

Para obtener información más detallada sobre cómo usar la API de Real-time Bidding con Java, consulta al README en los ejemplos de la API de Ofertas en tiempo real.

Python

A continuación, se incluye un ejemplo básico en el que se muestra cómo usar la API de Real-time Bidding con Python.

1. Descarga e instala el cliente de Python de la API de Google

   Ejemplo con pip:

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

2. Configura tus credenciales

   Todas las llamadas a la API requieren autenticación. crear una instancia Instancia service_account.Credentials con el servicio archivo de claves JSON de la cuenta que se mencionó anteriormente.

     credentials = service_account.Credentials.from_service_account_file(
         KEY_FILE, scopes=[SCOPE])

3. Crea un cliente para la API de Real-time Bidding

   Luego, puedes crear tu cliente de la API de Real-time Bidding con la Instancia service_account.Credentials:

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

4. Cómo realizar una operación

   Después de crear una instancia de un cliente para conectarse a la API, puedes realizar una operación. El siguiente código devuelve todos los datos de un comprador creatividades.

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

Para obtener información más detallada sobre cómo usar la API de Ad Exchange Buyer con Python, consulte al README en los ejemplos de la API de Ofertas en tiempo real.

PHP

Este es un ejemplo básico que muestra cómo usar la API de Real-time Bidding con o PHP.

1. Cómo configurar dependencias

   Si aún no lo has hecho, descarga y, luego, instala Composer. Luego, crea un composer.json con contenido como el siguiente:

   {
     "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"
       }
     ]
   }
   

   Por último, ejecuta el siguiente comando para instalar bibliotecas de dependencias:

   composer install

2. Configura un cliente

   Crea un Google_Client y úsalo para crear una instancia 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. Configura tus credenciales

   Todas las llamadas a la API requieren un token de acceso válido. Configura tu cliente para paso por el flujo de 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. Cómo realizar una operación

   Después de crear una instancia de un cliente para conectarse a la API OAuth 2.0, puedes usarlo para hacer una llamada a la API. El siguiente código muestra todas las creatividades de un comprador determinado:

   $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

Para obtener información más detallada sobre cómo usar la API de Ad Exchange Buyer con PHP, consulte al README en los ejemplos de la API de Ofertas en tiempo real.

.NET

A continuación, se incluye un ejemplo básico que muestra cómo usar la API de Real-time Bidding con C#.

1. Crea un proyecto nuevo

   Abre Visual Studio Code y crea un proyecto nuevo.

2. Agrega las referencias de biblioteca obligatorias a tu proyecto

   En el archivo *.csproj de tu proyecto, agrega un PackageReference entrada para Google.Apis, Google.Apis.Auth, Google.Apis.Core, Google.Apis.Oauth2.v2 y Google.Apis.RealTimeBidding.v1 A modo de ejemplo, esto podría verse de la siguiente manera:

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

   Puedes encontrar más información sobre estas dependencias en https://www.nuget.org/packages/.

3. Configura tus credenciales

   Todas las llamadas a la API requieren autenticación. crear un Credential mediante el correo electrónico y el archivo JSON de la cuenta de servicio.

   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. Crea un cliente para la API de Real-time Bidding

   Luego, puedes crear tu RealTimeBiddingService:

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

5. Cómo realizar una operación

   Después de crear una instancia de un cliente para conectarse a la API, puedes realizar una operación. El siguiente código enumera las creatividades de un Cuenta de comprador de Authorized Buyers asociada con tus credenciales.

   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

Para obtener información más detallada sobre el uso de la API de Real-time Bidding con C#, consulta el archivo README en el archivo Ejemplos de la API de Real-time Bidding.

Rita

Este es un ejemplo básico que muestra cómo usar la API de Real-time Bidding con Rita.

1. Descarga e instala el cliente de Ruby de la API de Google

   Si aún no lo has instalado, descarga e instala Bundler, Luego, crea un Gemfile con contenido como el siguiente:

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

   Por último, ejecuta el siguiente comando para instalar bibliotecas de dependencias:

   bundle

2. Configura tus credenciales

   Todas las llamadas a la API requieren autenticación. crear credenciales con el correo electrónico de la cuenta de servicio y el archivo JSON mencionados anteriormente.

   # 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. Crea un cliente para AdExchangeBuyer

   A continuación, puedes crear tu cliente de comprador de AdExchange autorizado mediante el credenciales:

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

4. Cómo realizar una operación

   Después de crear una instancia de un cliente para conectarse a la API, puedes realizar una operación. El siguiente código devuelve todos los datos de un comprador creatividades.

   # 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

Para obtener información más detallada sobre cómo usar la API de Real-time Bidding con Ruby, consulta al README en el archivo Ejemplos de la API de Real-time Bidding.

API de Ad Exchange Buyer II

Java

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

Rita

#!/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

Próximos pasos

• Lee la guía en segundo plano para obtener más información sobre las muestras y las opciones disponibles para desarrollar tus de Google Cloud.

• Después de configurar una biblioteca cliente, intenta extendiendo las muestras de código para satisfacer tus necesidades.

• Consulta la documentación de referencia para obtener versión con la que estás trabajando para obtener más información sobre la API.

• Si necesitas ayuda, visita el foro.

• Si se espera que tu aplicación realice ofertas en tiempo real, consulta el artículo RTB protocolo.

• Revisa las sugerencias para mejorar el rendimiento.

Responder una encuesta

Ayúdanos a mejorar esta documentación: cuéntanos qué aspectos funcionó y qué nos perdimos completando una guía rápida encuesta.