Endpoints

REST

Request

GET https://realtimebidding.googleapis.com/v1/bidders/12345678/endpoints/16?alt=json
Authorization: Bearer <INSERT_ACCESS_TOKEN_HERE>
Content-Type: application/json

Response

{
  "bidProtocol": "GOOGLE_RTB",
  "name": "bidders/12345678/endpoints/16",
  "tradingLocation": "US_EAST",
  "url": "https://test.testendpoint.com/testbidder"
}

C#

/* 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.RealTimeBidding.v1;
using Google.Apis.RealTimeBidding.v1.Data;
using Mono.Options;

using System;
using System.Collections.Generic;

namespace Google.Apis.RealTimeBidding.Examples.v1.Bidders.Endpoints
{
    /// <summary>
    /// Gets a single endpoint for the specified bidder and endpoint IDs.
    /// </summary>
    public class GetEndpoints : ExampleBase
    {
        private RealTimeBiddingService rtbService;

        /// <summary>
        /// Constructor.
        /// </summary>
        public GetEndpoints()
        {
            rtbService = Utilities.GetRealTimeBiddingService();
        }

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get => "Get an endpoint for the given bidder and endpoint IDs.";
        }

        /// <summary>
        /// Parse specified arguments.
        /// </summary>
        protected override Dictionary<string, object> ParseArguments(List<string> exampleArgs) {
            string[] requiredOptions = new string[] {"account_id", "endpoint_id"};
            bool showHelp = false;

            string accountId = null;
            string endpointId = null;

            OptionSet options = new OptionSet {
                "Get an endpoint for the given bidder and endpoint IDs.",
                {
                    "h|help",
                    "Show help message and exit.",
                    h => showHelp = h != null
                },
                {
                    "a|account_id=",
                    ("[Required] The resource ID of the bidders resource under which the " +
                     "endpoint exists. This will be used to construct the name used as a path " +
                     "parameter for the endpoints.get request."),
                    a => accountId = a
                },
                {
                    "e|endpoint_id=",
                    ("[Required] The resource ID of the endpoints resource that is being " +
                     "retrieved. This will be used to construct the name used as a path " +
                     "parameter for the endpoints.get request."),
                    e => endpointId = e
                },
            };

            List<string> extras = options.Parse(exampleArgs);
            var parsedArgs = new Dictionary<string, object>();

            // Show help message.
            if(showHelp == true)
            {
                options.WriteOptionDescriptions(Console.Out);
                Environment.Exit(0);
            }
            // Set arguments.
            parsedArgs["account_id"] = accountId;
            parsedArgs["endpoint_id"] = endpointId;
            // Validate that options were set correctly.
            Utilities.ValidateOptions(options, parsedArgs, requiredOptions, extras);

            return parsedArgs;
        }

        /// <summary>
        /// Run the example.
        /// </summary>
        /// <param name="parsedArgs">Parsed arguments for the example.</param>
        protected override void Run(Dictionary<string, object> parsedArgs)
        {
            string accountId = (string) parsedArgs["account_id"];
            string endpointId = (string) parsedArgs["endpoint_id"];
            string name = $"bidders/{accountId}/endpoints/{endpointId}";

            BiddersResource.EndpointsResource.GetRequest request =
                rtbService.Bidders.Endpoints.Get(name);
            Endpoint response = null;

            Console.WriteLine("Getting endpoint with name: {0}", name);

            try
            {
                response = request.Execute();
            }
            catch (System.Exception exception)
            {
                throw new ApplicationException(
                    $"Real-time Bidding API returned error response:\n{exception.Message}");
            }

            Utilities.PrintEndpoint(response);
        }
    }
}

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.realtimebidding.v1.bidders.endpoints;

import com.google.api.services.realtimebidding.v1.RealTimeBidding;
import com.google.api.services.realtimebidding.v1.model.Endpoint;
import com.google.api.services.samples.authorizedbuyers.realtimebidding.Utils;
import java.io.IOException;
import java.security.GeneralSecurityException;
import net.sourceforge.argparse4j.ArgumentParsers;
import net.sourceforge.argparse4j.inf.ArgumentParser;
import net.sourceforge.argparse4j.inf.ArgumentParserException;
import net.sourceforge.argparse4j.inf.Namespace;

/**
 * This sample illustrates how to get a single endpoint for the specified bidder and endpoint IDs.
 */
public class GetEndpoints {

  public static void execute(RealTimeBidding client, Namespace parsedArgs) throws IOException {
    Long accountId = parsedArgs.getLong("account_id");
    Long endpointId = parsedArgs.getLong("endpoint_id");
    String name = String.format("bidders/%s/endpoints/%s", accountId, endpointId);

    Endpoint endpoint = client.bidders().endpoints().get(name).execute();

    System.out.printf(
        "Get endpoint with ID '%s' for bidder account with ID '%s'.\n", endpointId, accountId);
    Utils.printEndpoint(endpoint);
  }

  public static void main(String[] args) {
    ArgumentParser parser =
        ArgumentParsers.newFor("GetBidders")
            .build()
            .defaultHelp(true)
            .description(("Get an endpoint for the given bidder and endpoint IDs."));
    parser
        .addArgument("-a", "--account_id")
        .help(
            "The resource ID of the bidders resource under which the endpoint exists. This will be"
                + " used to construct the name used as a path parameter for the endpoints.get "
                + "request.")
        .required(true)
        .type(Long.class);
    parser
        .addArgument("-e", "--endpoint_id")
        .help(
            "The resource ID of the endpoints resource that is being retrieved. This will be used"
                + " to construct the name used as a path parameter for the endpoints.get request.")
        .required(true)
        .type(Long.class);

    Namespace parsedArgs = null;
    try {
      parsedArgs = parser.parseArgs(args);
    } catch (ArgumentParserException ex) {
      parser.handleError(ex);
      System.exit(1);
    }

    RealTimeBidding client = null;
    try {
      client = Utils.getRealTimeBiddingClient();
    } catch (IOException ex) {
      System.out.printf("Unable to create RealTimeBidding API service:\n%s", ex);
      System.out.println("Did you specify a valid path to a service account key file?");
      System.exit(1);
    } catch (GeneralSecurityException ex) {
      System.out.printf("Unable to establish secure HttpTransport:\n%s", ex);
      System.exit(1);
    }

    try {
      execute(client, parsedArgs);
    } catch (IOException ex) {
      System.out.printf("RealTimeBidding API returned error response:\n%s", ex);
      System.exit(1);
    }
  }
}

PHP

<?php

/**
 * 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.
 */

namespace Google\Ads\AuthorizedBuyers\RealTimeBidding\Examples\V1\Bidders_Endpoints;

use Google\Ads\AuthorizedBuyers\RealTimeBidding\ExampleUtil\BaseExample;
use Google\Ads\AuthorizedBuyers\RealTimeBidding\ExampleUtil\Config;

/**
 * This example illustrates how to get a single endpoint for the specified bidder and endpoint IDs.
 */
class GetEndpoints extends BaseExample
{

    public function __construct($client)
    {
        $this->service = Config::getGoogleServiceRealTimeBidding($client);
    }

    /**
     * @see BaseExample::getInputParameters()
     */
    protected function getInputParameters()
    {
        return [
            [
                'name' => 'account_id',
                'display' => 'Account ID',
                'required' => true,
                'description' =>
                    'The resource ID of the bidders resource under which the endpoint exists. ' .
                    'This will be used to construct the name used as a path parameter for the ' .
                    'endpoints.get request.'
            ],
            [
                'name' => 'endpoint_id',
                'display' => 'Endpoint ID',
                'required' => true,
                'description' =>
                    'The resource ID of the endpoints resource that is being retrieved. This ' .
                    'will be used to construct the name used as a path parameter for the ' .
                    'endpoints.get request.'
            ],
        ];
    }

    /**
     * @see BaseExample::run()
     */
    public function run()
    {
        $values = $this->formValues;

        $name = "bidders/$values[account_id]/endpoints/$values[endpoint_id]";

        try {
            $endpoint = $this->service->bidders_endpoints->get($name);
            print '<h2>Found endpoint.</h2>';
            $this->printResult($endpoint);
        } catch (Google_Service_Exception $ex) {
            if ($ex->getCode() === 404 || $ex->getCode() === 403) {
                print '<h1>Endpoint not found or can\'t access endpoint.</h1>';
            } else {
                throw $ex;
            }
        }
    }

    /**
     * @see BaseExample::getName()
     */
    public function getName()
    {
        return 'Get Endpoint';
    }
}

Python

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

"""Gets a single endpoint for the specified bidder and endpoint IDs."""


import argparse
import os
import pprint
import sys

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

from googleapiclient.errors import HttpError

import util


_ENDPOINTS_NAME_TEMPLATE = 'bidders/%s/endpoints/%s'

DEFAULT_BIDDER_RESOURCE_ID = 'ENTER_BIDDER_RESOURCE_ID_HERE'
DEFAULT_ENDPOINT_RESOURCE_ID = 'ENTER_ENDPOINT_RESOURCE_ID_HERE'


def main(realtimebidding, account_id, endpoint_id):
  print(f'Get endpoint with ID "{endpoint_id}" for bidder account with ID '
        f'"{account_id}":')
  try:
    # Construct and execute the request.
    response = realtimebidding.bidders().endpoints().get(
        name=_ENDPOINTS_NAME_TEMPLATE % (account_id, endpoint_id)).execute()
  except HttpError as e:
    print(e)
    sys.exit(1)

  pprint.pprint(response)


if __name__ == '__main__':
  try:
    service = util.GetService(version='v1')
  except IOError as ex:
    print(f'Unable to create realtimebidding service - {ex}')
    print('Did you specify the key file in util.py?')
    sys.exit(1)

  parser = argparse.ArgumentParser(
      description=('Get an endpoint for the given bidder and endpoint IDs.'))
  # Required fields.
  parser.add_argument(
      '-a', '--account_id', default=DEFAULT_BIDDER_RESOURCE_ID,
      help=('The resource ID of the bidders resource under which the endpoint '
            'exists. This will be used to construct the name used as a path '
            'parameter for the endpoints.get request.'))
  parser.add_argument(
      '-e', '--endpoint_id', default=DEFAULT_ENDPOINT_RESOURCE_ID,
      help=('The resource ID of the endpoints resource that is being '
            'retrieved. This will be used to construct the name used as a '
            'path parameter for the endpoints.get request.'))

  args = parser.parse_args()

  main(service, args.account_id, args.endpoint_id)

Ruby

#!/usr/bin/env ruby
# Encoding: utf-8
#
# Copyright:: Copyright 2021 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.
#
# Gets a single endpoint for the specified bidder and endpoint IDs.

require 'optparse'

require_relative '../../../util'


def get_endpoints(realtimebidding, options)
  name = "bidders/#{options[:account_id]}/endpoints/#{options[:endpoint_id]}"

  puts "Get endpoint with name '#{name}'"

  endpoint = realtimebidding.get_bidder_endpoint(name)
  print_endpoint(endpoint)
end


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

  # Set options and default values for fields used in this example.
  options = [
    Option.new(
      'account_id',
      'The resource ID of the bidders resource under which the endpoint exists. This will be ' \
      'used to construct the name used as a path parameter for the endpoints.get request.',
      type: Integer, short_alias: 'a', required: true, default_value: nil
    ),
    Option.new(
      'endpoint_id',
      'The resource ID of the endpoints resource that is being retrieved. This will be used to '\
      'construct the name used as a path parameter for the endpoints.get request.',
      type: Integer, short_alias: 'e', required: true, default_value: nil
    ),
  ]

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

  begin
    get_endpoints(service, opts)
  rescue Google::Apis::ServerError => e
    raise "The following server error occured:\n#{e.message}"
  rescue Google::Apis::ClientError => e
    raise "Invalid client request:\n#{e.message}"
  rescue Google::Apis::AuthorizationError => e
    raise "Authorization error occured:\n#{e.message}"
  end
end

REST

Request

GET https://realtimebidding.googleapis.com/v1/bidders/12345678/endpoints?pageSize=50&alt=json
Authorization: Bearer <INSERT_ACCESS_TOKEN_HERE>
Content-Type: application/json

Response

{
  "endpoints": [
    {
      "bidProtocol": "GOOGLE_RTB",
      "name": "bidders/12345678/endpoints/16",
      "tradingLocation": "US_EAST",
      "url": "https://test.testendpoint.com/testbidder"
    }
  ]
}

C#

/* 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.RealTimeBidding.v1;
using Google.Apis.RealTimeBidding.v1.Data;
using Mono.Options;

using System;
using System.Collections.Generic;

namespace Google.Apis.RealTimeBidding.Examples.v1.Bidders.Endpoints
{
    /// <summary>
    /// Lists endpoints for the given bidder's account ID.
    /// </summary>
    public class ListEndpoints : ExampleBase
    {
        private RealTimeBiddingService rtbService;

        /// <summary>
        /// Constructor.
        /// </summary>
        public ListEndpoints()
        {
            rtbService = Utilities.GetRealTimeBiddingService();
        }

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get => "This code example lists all endpoints for the given bidder account.";
        }

        /// <summary>
        /// Parse specified arguments.
        /// </summary>
        protected override Dictionary<string, object> ParseArguments(List<string> exampleArgs) {
            string[] requiredOptions = new string[] {"account_id"};
            bool showHelp = false;
            string accountId = null;
            int? pageSize = null;

            OptionSet options = new OptionSet {
                "List all endpoints for the given bidder account.",
                {
                    "h|help",
                    "Show help message and exit.",
                    h => showHelp = h != null
                },
                {
                    "a|account_id=",
                    ("[Required] The resource ID of the bidders resource under which the " +
                     "endpoint exists. This will be used to construct the parent used as  path " +
                     "parameter for the endpoints.list request."),
                    a => accountId =  a
                },
                {
                    "p|page_size=",
                    ("The number of rows to return per page. The server may return fewer rows " +
                     "than specified."),
                    (int p) => pageSize =  p
                },
            };

            List<string> extras = options.Parse(exampleArgs);
            var parsedArgs = new Dictionary<string, object>();

            // Show help message.
            if(showHelp == true)
            {
                options.WriteOptionDescriptions(Console.Out);
                Environment.Exit(0);
            }
            // Set arguments.
            parsedArgs["account_id"] = accountId;
            parsedArgs["page_size"] = pageSize ?? Utilities.MAX_PAGE_SIZE;
            // Validate that options were set correctly.
            Utilities.ValidateOptions(options, parsedArgs, requiredOptions, extras);

            return parsedArgs;
        }

        /// <summary>
        /// Run the example.
        /// </summary>
        /// <param name="parsedArgs">Parsed arguments for the example.</param>
        protected override void Run(Dictionary<string, object> parsedArgs)
        {
            string accountId = (string) parsedArgs["account_id"];
            string parent = $"bidders/{accountId}";
            string pageToken = null;

            Console.WriteLine(@"Listing endpoints for bidder account ""{0}""", accountId);
            do
            {
                BiddersResource.EndpointsResource.ListRequest request = rtbService.Bidders.Endpoints.List(parent);
                request.PageSize = (int) parsedArgs["page_size"];
                request.PageToken = pageToken;

                ListEndpointsResponse page = null;

                try
                {
                    page = request.Execute();
                }
                catch (System.Exception exception)
                {
                    throw new ApplicationException(
                        $"Real-time Bidding API returned error response:\n{exception.Message}");
                }

                var endpoints = page.Endpoints;
                pageToken = page.NextPageToken;

                if(endpoints == null)
                {
                    Console.WriteLine("No endpoints found.");
                }
                else
                {
                    foreach (Endpoint endpoint in endpoints)
                        {
                            Utilities.PrintEndpoint(endpoint);
                        }
                }
            }
            while(pageToken != null);
        }
    }
}

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.realtimebidding.v1.bidders.endpoints;

import com.google.api.services.realtimebidding.v1.RealTimeBidding;
import com.google.api.services.realtimebidding.v1.model.Endpoint;
import com.google.api.services.realtimebidding.v1.model.ListEndpointsResponse;
import com.google.api.services.samples.authorizedbuyers.realtimebidding.Utils;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.List;
import net.sourceforge.argparse4j.ArgumentParsers;
import net.sourceforge.argparse4j.inf.ArgumentParser;
import net.sourceforge.argparse4j.inf.ArgumentParserException;
import net.sourceforge.argparse4j.inf.Namespace;

/** This sample illustrates how to list endpoints for the given bidder's account ID. */
public class ListEndpoints {

  public static void execute(RealTimeBidding client, Namespace parsedArgs) throws IOException {
    Long accountId = parsedArgs.getLong("account_id");
    String parent = String.format("bidders/%s", accountId);
    Integer pageSize = parsedArgs.getInt("page_size");
    String pageToken = null;

    System.out.printf("Listing endpoints for bidder account '%s':\n", accountId);

    do {
      List<Endpoint> endpoints = null;

      ListEndpointsResponse response =
          client
              .bidders()
              .endpoints()
              .list(parent)
              .setPageSize(pageSize)
              .setPageToken(pageToken)
              .execute();

      endpoints = response.getEndpoints();
      pageToken = response.getNextPageToken();

      if (endpoints == null) {
        System.out.println("No endpoints found.");
      } else {
        for (Endpoint endpoint : endpoints) {
          Utils.printEndpoint(endpoint);
        }
      }
    } while (pageToken != null);
  }

  public static void main(String[] args) {
    ArgumentParser parser =
        ArgumentParsers.newFor("ListBidders")
            .build()
            .defaultHelp(true)
            .description("Lists endpoints for the given bidder account.");
    parser
        .addArgument("-a", "--account_id")
        .help(
            "The resource ID of the bidders resource under which the endpoint exists. This will be"
                + " used to construct the name used as a path parameter for the endpoints.list "
                + "request.")
        .required(true)
        .type(Long.class);
    parser
        .addArgument("-p", "--page_size")
        .help(
            "The number of rows to return per page. The server may return fewer rows than "
                + "specified.")
        .setDefault(Utils.getMaximumPageSize())
        .type(Integer.class);

    Namespace parsedArgs = null;
    try {
      parsedArgs = parser.parseArgs(args);
    } catch (ArgumentParserException ex) {
      parser.handleError(ex);
      System.exit(1);
    }

    RealTimeBidding client = null;
    try {
      client = Utils.getRealTimeBiddingClient();
    } catch (IOException ex) {
      System.out.printf("Unable to create RealTimeBidding API service:\n%s", ex);
      System.out.println("Did you specify a valid path to a service account key file?");
      System.exit(1);
    } catch (GeneralSecurityException ex) {
      System.out.printf("Unable to establish secure HttpTransport:\n%s", ex);
      System.exit(1);
    }

    try {
      execute(client, parsedArgs);
    } catch (IOException ex) {
      System.out.printf("RealTimeBidding API returned error response:\n%s", ex);
      System.exit(1);
    }
  }
}

PHP

<?php

/**
 * 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.
 */

namespace Google\Ads\AuthorizedBuyers\RealTimeBidding\Examples\V1\Bidders_Endpoints;

use Google\Ads\AuthorizedBuyers\RealTimeBidding\ExampleUtil\BaseExample;
use Google\Ads\AuthorizedBuyers\RealTimeBidding\ExampleUtil\Config;

/**
 * This example illustrates how to list a bidder's endpoints.
 */
class ListEndpoints extends BaseExample
{

    public function __construct($client)
    {
        $this->service = Config::getGoogleServiceRealTimeBidding($client);
    }

    /**
     * @see BaseExample::getInputParameters()
     */
    protected function getInputParameters()
    {
        return [
            [
                'name' => 'account_id',
                'display' => 'Account ID',
                'required' => true,
                'description' =>
                    'The resource ID of the bidders resource under which the endpoint exists. ' .
                    'This will be used to construct the name used as a path parameter for the ' .
                    'endpoints.list request.'
            ],
            [
                'name' => 'page_size',
                'display' => 'Page size',
                'required' => false,
                'description' =>
                    'The number of rows to return per page. The server may return fewer rows ' .
                    'than specified.',
                'default' => 10
            ]
        ];
    }

    /**
     * @see BaseExample::run()
     */
    public function run()
    {
        $values = $this->formValues;

        $parentName = "bidders/$values[account_id]";

        $queryParams = [
            'pageSize' => $values['page_size']
        ];

        $result = $this->service->bidders_endpoints->listBiddersEndpoints($parentName, $queryParams);

        print "<h2>Endpoints found for '$parentName':</h2>";
        if (empty($result['endpoints'])) {
            print '<p>No Endpoints found</p>';
        } else {
            foreach ($result['endpoints'] as $endpoint) {
                $this->printResult($endpoint);
            }
        }
    }

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

Python

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

"""Lists endpoints for the given bidder's account ID."""


import argparse
import os
import pprint
import sys

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

from googleapiclient.errors import HttpError

import util


_BIDDER_NAME_TEMPLATE = 'bidders/%s'

DEFAULT_BIDDER_RESOURCE_ID = 'ENTER_BIDDER_RESOURCE_ID_HERE'


def main(realtimebidding, args):
  account_id = args.account_id
  page_size = args.page_size

  page_token = None
  more_pages = True

  print(f'Listing endpoints for bidder account: "{account_id}".')

  while more_pages:
    try:
      # Construct and execute the request.
      response = realtimebidding.bidders().endpoints().list(
          parent=_BIDDER_NAME_TEMPLATE % account_id, pageToken=page_token,
          pageSize=page_size).execute()
    except HttpError as e:
      print(e)
      sys.exit(1)

    pprint.pprint(response if response else 'No endpoints found.')

    page_token = response.get('nextPageToken')
    more_pages = bool(page_token)


if __name__ == '__main__':
  try:
    service = util.GetService(version='v1')
  except IOError as ex:
    print(f'Unable to create realtimebidding service - {ex}')
    print('Did you specify the key file in util.py?')
    sys.exit(1)

  parser = argparse.ArgumentParser(
      description=('Lists endpoints for the given bidder account.'))

  # Required fields.
  parser.add_argument(
      '-a', '--account_id', default=DEFAULT_BIDDER_RESOURCE_ID,
      help=('The resource ID of the bidders resource under which the '
            'endpoint exists. This will be used to construct the parent used '
            'as a path parameter for the endpoints.list request.'))
  # Optional fields.
  parser.add_argument(
      '-p', '--page_size', default=util.MAX_PAGE_SIZE,
      help=('The number of rows to return per page. The server may return '
            'fewer rows than specified.'))

  args = parser.parse_args()

  main(service, args)

Ruby

#!/usr/bin/env ruby
# Encoding: utf-8
#
# Copyright:: Copyright 2021 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.
#
# Lists endpoints for the given bidder's account ID.

require 'optparse'

require_relative '../../../util'


def list_endpoints(realtimebidding, options)
  parent = "bidders/#{options[:account_id]}"
  page_size = options[:page_size]

  page_token = nil

  puts "Listing endpoints for bidder with name: '#{parent}'"
  begin
    response = realtimebidding.list_bidder_endpoints(
        parent, page_size: page_size, page_token: page_token
    )

    page_token = response.next_page_token

    unless response.endpoints.nil?
      response.endpoints.each do |endpoint|
        print_endpoint(endpoint)
      end
    else
      puts 'No endpoints found.'
    end
  end until page_token == nil
end


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

  # Set options and default values for fields used in this example.
  options = [
    Option.new(
      'account_id',
      'The resource ID of the bidders resource under which the endpoints exist. This will be ' \
      'used to construct the parent used as a path parameter for the endpoints.list request.',
      type: Integer, short_alias: 'a', required: true, default_value: nil
    ),
    Option.new(
      'page_size', 'The number of rows to return per page. The server may return fewer rows than specified.',
      type: Array, short_alias: 'u', required: false, default_value: MAX_PAGE_SIZE
    ),
  ]

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

  begin
    list_endpoints(service, opts)
  rescue Google::Apis::ServerError => e
    raise "The following server error occured:\n#{e.message}"
  rescue Google::Apis::ClientError => e
    raise "Invalid client request:\n#{e.message}"
  rescue Google::Apis::AuthorizationError => e
    raise "Authorization error occured:\n#{e.message}"
  end
end

REST

Request

PATCH https://realtimebidding.googleapis.com/v1/bidders/12345678/endpoints/54321?updateMask=maximumQps%2CtradingLocation%2CbidProtocol
Authorization: Bearer <INSERT_ACCESS_TOKEN_HERE>
Content-Type: application/json

{
  "maximumQps": 1,
  "tradingLocation": "US_EAST",
  "bidProtocol": "GOOGLE_RTB"
}

Response

{
  "name": "bidders/12345678/endpoints/54321",
  "url": "https://test.testendpoint.com/testbidder2",
  "maximumQps": "1",
  "tradingLocation": "US_EAST",
  "bidProtocol": "GOOGLE_RTB"
}

C#

/* 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.RealTimeBidding.v1;
using Google.Apis.RealTimeBidding.v1.Data;
using Mono.Options;

using System;
using System.Collections.Generic;

namespace Google.Apis.RealTimeBidding.Examples.v1.Bidders.Endpoints
{
    /// <summary>
    /// Patches an endpoint with a specified name.
    /// </summary>
    public class PatchEndpoints : ExampleBase
    {
        private RealTimeBiddingService rtbService;

        /// <summary>
        /// Constructor.
        /// </summary>
        public PatchEndpoints()
        {
            rtbService = Utilities.GetRealTimeBiddingService();
        }

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get => "This code example patches a specified endpoint.";
        }

        /// <summary>
        /// Parse specified arguments.
        /// </summary>
        protected override Dictionary<string, object> ParseArguments(List<string> exampleArgs) {
            string[] requiredOptions = new string[] {"account_id", "endpoint_id"};
            bool showHelp = false;

            string accountId = null;
            string endpointId = null;
            string bidProtocol = null;
            long? maximumQps = null;
            string tradingLocation = null;


            OptionSet options = new OptionSet {
                "Patches a specified endpoint.",
                {
                    "h|help",
                    "Show help message and exit.",
                    h => showHelp = h != null
                },
                {
                    "a|account_id=",
                    ("[Required] The resource ID of the bidders resource under which the " +
                     "endpoint exists."),
                    a => accountId = a
                },
                {
                    "e|endpoint_id=",
                    "[Required] The resource ID of the endpoint to be patched.",
                    e => endpointId = e
                },
                {
                    "b|bid_protocol=",
                    "The real-time bidding protocol that the endpoint is using.",
                    b => bidProtocol = b
                },
                {
                    "m|maximum_qps=",
                    "The maximum number of queries per second allowed to be sent to the endpoint.",
                    (long m) => maximumQps = m
                },
                {
                    "t|trading_location=",
                    ("Region where the endpoint and its infrastructure is located; corresponds " +
                     "to the location of users that bid requests are sent for."),
                    t => tradingLocation = t
                },
            };

            List<string> extras = options.Parse(exampleArgs);
            var parsedArgs = new Dictionary<string, object>();

            // Show help message.
            if(showHelp == true)
            {
                options.WriteOptionDescriptions(Console.Out);
                Environment.Exit(0);
            }
            // Set arguments.
            parsedArgs["account_id"] = accountId;
            parsedArgs["endpoint_id"] = endpointId;
            parsedArgs["bid_protocol"] = bidProtocol ?? "GOOGLE_RTB";
            parsedArgs["maximum_qps"] = maximumQps ?? 1L;
            parsedArgs["trading_location"] = tradingLocation ?? "US_EAST";
            // Validate that options were set correctly.
            Utilities.ValidateOptions(options, parsedArgs, requiredOptions, extras);

            return parsedArgs;
        }

        /// <summary>
        /// Run the example.
        /// </summary>
        /// <param name="parsedArgs">Parsed arguments for the example.</param>
        protected override void Run(Dictionary<string, object> parsedArgs)
        {
            string accountId = (string) parsedArgs["account_id"];
            string endpointId = (string) parsedArgs["endpoint_id"];
            string name = $"bidders/{accountId}/endpoints/{endpointId}";

            Endpoint body = new Endpoint();
            body.BidProtocol = (string) parsedArgs["bid_protocol"];
            body.MaximumQps = (long?) parsedArgs["maximum_qps"];
            body.TradingLocation = (string) parsedArgs["trading_location"];

            BiddersResource.EndpointsResource.PatchRequest request =
                rtbService.Bidders.Endpoints.Patch(body, name);
            Endpoint response = null;

            Console.WriteLine("Patching endpoint with name {0}:", name);

            try
            {
                response = request.Execute();
            }
            catch (System.Exception exception)
            {
                throw new ApplicationException(
                    $"Real-time Bidding API returned error response:\n{exception.Message}");
            }

            Utilities.PrintEndpoint(response);
        }
    }
}

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.realtimebidding.v1.bidders.endpoints;

import com.google.api.services.realtimebidding.v1.RealTimeBidding;
import com.google.api.services.realtimebidding.v1.model.Endpoint;
import com.google.api.services.samples.authorizedbuyers.realtimebidding.Utils;
import java.io.IOException;
import java.security.GeneralSecurityException;
import net.sourceforge.argparse4j.ArgumentParsers;
import net.sourceforge.argparse4j.inf.ArgumentParser;
import net.sourceforge.argparse4j.inf.ArgumentParserException;
import net.sourceforge.argparse4j.inf.Namespace;

/** Patches an endpoint with a specified name. */
public class PatchEndpoints {

  public static void execute(RealTimeBidding client, Namespace parsedArgs) throws IOException {
    Long accountId = parsedArgs.getLong("account_id");

    String name =
        String.format("bidders/%s/endpoints/%s", accountId, parsedArgs.getLong("endpoint_id"));
    String updateMask = "maximumQps,tradingLocation,bidProtocol";

    Endpoint body = new Endpoint();
    body.setBidProtocol(parsedArgs.getString("bid_protocol"));
    body.setMaximumQps(parsedArgs.getLong("maximum_qps"));
    body.setTradingLocation(parsedArgs.getString("trading_location"));

    Endpoint endpoint =
        client.bidders().endpoints().patch(name, body).setUpdateMask(updateMask).execute();

    System.out.printf("Patched endpoint with name '%s':\n", name);
    Utils.printEndpoint(endpoint);
  }

  public static void main(String[] args) {
    ArgumentParser parser =
        ArgumentParsers.newFor("PatchEndpoints")
            .build()
            .defaultHelp(true)
            .description(("Patches a specified endpoint."));
    parser
        .addArgument("-a", "--account_id")
        .help("The resource ID of the bidders resource under which the endpoint exists.")
        .required(true)
        .type(Long.class);
    parser
        .addArgument("-e", "--endpoint_id")
        .help("The resource ID of the endpoint to be patched.")
        .required(true)
        .type(Long.class);
    parser
        .addArgument("-b", "--bid_protocol")
        .help("The real-time bidding protocol that the endpoint is using.")
        .setDefault("GOOGLE_RTB");
    parser
        .addArgument("-m", "--maximum_qps")
        .help("The maximum number of queries per second allowed to be sent to the endpoint.")
        .type(Long.class)
        .setDefault(1L);
    parser
        .addArgument("-t", "--trading_location")
        .help(
            "Region where the endpoint and its infrastructure is located; corresponds to the "
                + "location of users that bid requests are sent for.")
        .setDefault("US_EAST");

    Namespace parsedArgs = null;
    try {
      parsedArgs = parser.parseArgs(args);
    } catch (ArgumentParserException ex) {
      parser.handleError(ex);
      System.exit(1);
    }

    RealTimeBidding client = null;
    try {
      client = Utils.getRealTimeBiddingClient();
    } catch (IOException ex) {
      System.out.printf("Unable to create RealTimeBidding API service:\n%s", ex);
      System.out.println("Did you specify a valid path to a service account key file?");
      System.exit(1);
    } catch (GeneralSecurityException ex) {
      System.out.printf("Unable to establish secure HttpTransport:\n%s", ex);
      System.exit(1);
    }

    try {
      execute(client, parsedArgs);
    } catch (IOException ex) {
      System.out.printf("RealTimeBidding API returned error response:\n%s", ex);
      System.exit(1);
    }
  }
}

PHP

<?php

/**
 * 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.
 */

namespace Google\Ads\AuthorizedBuyers\RealTimeBidding\Examples\V1\Bidders_Endpoints;

use Google\Ads\AuthorizedBuyers\RealTimeBidding\ExampleUtil\BaseExample;
use Google\Ads\AuthorizedBuyers\RealTimeBidding\ExampleUtil\Config;
use Google_Service_RealTimeBidding_Endpoint;

/**
 * Patches an endpoint with the specified name.
 */
class PatchEndpoints extends BaseExample
{

    public function __construct($client)
    {
        $this->service = Config::getGoogleServiceRealTimeBidding($client);
    }

    /**
     * @see BaseExample::getInputParameters()
     */
    protected function getInputParameters()
    {
        return [
            [
                'name' => 'account_id',
                'display' => 'Account ID',
                'description' =>
                    'The resource ID of the bidders resource under which the endpoint ' .
                    'exists.',
                'required' => true
            ],
            [
                'name' => 'endpoint_id',
                'display' => 'Endpoint ID',
                'description' =>
                    'The resource ID of the endpoint to be patched.',
                'required' => true,
            ],
            [
                'name' => 'bid_protocol',
                'display' => 'Bid protocol',
                'description' =>
                    'The real-time bidding protocol that the endpoint is using.',
                'required' => false,
                'default' => 'GOOGLE_RTB'
            ],
            [
                'name' => 'maximum_qps',
                'display' => 'Maximum QPS',
                'description' =>
                    'The maximum number of queries per second allowed to be sent to the endpoint.',
                'required' => false,
                'default' => '1'
            ],
            [
                'name' => 'trading_location',
                'display' => 'Trading location',
                'description' =>
                    'Region where the endpoint and its infrastructure is located; corresponds ' .
                    'to the location of users that bid requests are sent for.',
                'required' => false,
                'default' => 'US_EAST'
            ]
        ];
    }

    /**
     * @see BaseExample::run()
     */
    public function run()
    {
        $values = $this->formValues;
        $name = "bidders/$values[account_id]/endpoints/$values[endpoint_id]";

        $body = new Google_Service_RealTimeBidding_Endpoint();
        $body->bidProtocol = $values['bid_protocol'];
        $body->maximumQps = $values['maximum_qps'];
        $body->tradingLocation = $values['trading_location'];

        $queryParams = [
            'updateMask' =>
                'maximumQps,tradingLocation,bidProtocol'
        ];

        print "<h2>Patching an endpoint with name '$name':</h2>";
        $result = $this->service->bidders_endpoints->patch($name, $body, $queryParams);
        $this->printResult($result);
    }

    /**
     * @see BaseExample::getName()
     */
    public function getName()
    {
        return 'Patch Endpoint';
    }
}

Python

#!/usr/bin/python
#
# Copyright 2021 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 patches an endpoint with a specified name."""


import argparse
import os
import pprint
import sys
import uuid

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

from googleapiclient.errors import HttpError

import util


_ENDPOINT_NAME_TEMPLATE = 'bidders/%s/endpoints/%s'

DEFAULT_BIDDER_RESOURCE_ID = 'ENTER_BIDDER_RESOURCE_ID_HERE'
DEFAULT_ENDPOINT_RESOURCE_ID = 'ENTER_ENDPOINT_RESOURCE_ID_HERE'


def main(realtimebidding, args):
  endpoint_name = _ENDPOINT_NAME_TEMPLATE % (args.account_id, args.endpoint_id)

  body = {
      'maximumQps': args.maximum_qps,
      'tradingLocation': args.trading_location,
      'bidProtocol': args.bid_protocol
  }

  update_mask = 'maximumQps,tradingLocation,bidProtocol'

  print(f'Patching an endpoint with name: "{endpoint_name}":')
  try:
    response = realtimebidding.bidders().endpoints().patch(
        name=endpoint_name, body=body,
        updateMask=update_mask).execute()
  except HttpError as e:
    print(e)
    sys.exit(1)

  pprint.pprint(response)


if __name__ == '__main__':
  try:
    service = util.GetService(version='v1')
  except IOError as ex:
    print(f'Unable to create realtimebidding service - {ex}')
    print('Did you specify the key file in util.py?')
    sys.exit(1)

  parser = argparse.ArgumentParser(
      description='Patches a specified endpoint.')
  # Required fields.
  parser.add_argument(
      '-a', '--account_id', default=DEFAULT_BIDDER_RESOURCE_ID,
      help=('The resource ID of the bidders resource under which the '
            'endpoint exists.'))
  parser.add_argument(
      '-e', '--endpoint_id', default=DEFAULT_ENDPOINT_RESOURCE_ID,
      help='The resource ID of the endpoint to be patched.')
  # Optional fields.
  parser.add_argument(
      '-b', '--bid_protocol', default='GOOGLE_RTB',
      help='The real-time bidding protocol that the endpoint is using.')
  parser.add_argument(
      '-m', '--maximum_qps', default='1',
      help=('The maximum number of queries per second allowed to be sent to '
            'the endpoint.'))
  parser.add_argument(
      '-t', '--trading_location', default='US_EAST',
      help=('Region where the endpoint and its infrastructure is located; '
            'corresponds to the location of users that bid requests are sent '
            'for.'))

  args = parser.parse_args()

  main(service, args)

Ruby

#!/usr/bin/env ruby
# Encoding: utf-8
#
# Copyright:: Copyright 2021 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.
#
# Patches an endpoint for the given bidder account and endpoint IDs.

require 'optparse'
require 'securerandom'

require_relative '../../../util'


def patch_pretargeting_configs(realtimebidding, options)
  name = "bidders/#{options[:account_id]}/endpoints/#{options[:endpoint_id]}"

  body = Google::Apis::RealtimebiddingV1::Endpoint.new(
    maximum_qps: options[:maximum_qps],
    trading_location: options[:trading_location],
    bid_protocol: options[:bid_protocol]
  )

  update_mask = 'maximumQps,tradingLocation,bidProtocol'

  puts "Patching an endpoint with name: '#{name}'"

  endpoint = realtimebidding.patch_bidder_endpoint(name, body, update_mask: update_mask)
  print_endpoint(endpoint)
end


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

  # Set options and default values for fields used in this example.
  options = [
    Option.new(
      'account_id',
      'The resource ID of the bidders resource under which the endpoint exists, This will be used to construct the '\
      'name used as a path parameter for the endpoints.patch request.',
      type: Integer, short_alias: 'a', required: true, default_value: nil
    ),
    Option.new(
      'endpoint_id',
      'The resource ID of the endpoint to be patched. This will be used to construct the name used as a path '\
      'parameter for the endpoints.patch request.',
      type: Integer, short_alias: 'e', required: true, default_value: nil
    ),
    Option.new(
      'bid_protocol', 'The real-time bidding protocol that the endpoint is using.',
      short_alias: 'b', required: false, default_value: 'GOOGLE_RTB'
    ),
    Option.new(
      'maximum_qps',
      'The maximum number of queries per second allowed to be sent to the endpoint.',
      short_alias: 'm', required: false, default_value: '1'
    ),
    Option.new(
      'trading_location',
      'Region where the endpoint and its infrastructure is located; corresponds to the location of users that bid '\
      'requests are sent for.',
      short_alias: 't', required: false, default_value: 'US_EAST'
    ),
  ]

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

  begin
    patch_pretargeting_configs(service, opts)
  rescue Google::Apis::ServerError => e
    raise "The following server error occured:\n#{e.message}"
  rescue Google::Apis::ClientError => e
    raise "Invalid client request:\n#{e.message}"
  rescue Google::Apis::AuthorizationError => e
    raise "Authorization error occured:\n#{e.message}"
  end
end