Manage publisher connections

A publisher connection is a connection between a bidder and a publisher in Open Bidding.

Bidders can use publisher connections to control which sellers they receive bid requests from. Publisher connections are only initiated by the publisher, and approved or rejected by the bidder. Accepting a connection request lets the publisher send bid requests to the bidder, so we recommend bidders only accept requests after signing a contract with the publisher.

You can use the bidders.publisherConnections resource to manage publisher connection requests.

In this guide, bidderId is your account ID, and publisherId is a publisher ID from the publisher’s ads.txt or app-ads.txt file. This file is hosted by the publisher’s website or app, for example: http://example.com/ads.txt.

You can also use list to view the IDs for publishers that have sent you a connection request.

Here are some ways you can use the bidders.publisherConnections resource:

View connections

Get individual connection

You can view a specific publisher connection with the get method. This method returns a PublisherConnection object.

Here's a sample get request:

REST

Request

GET https://realtimebidding.googleapis.com/v1/bidders/{bidderId}/publisherConnections/{publisherId}

Response

{
  "name":"bidders/12345/publisherConnections/pub-12345",
  "publisherPlatform":"GOOGLE_AD_MANAGER",
  "displayName":"Company A",
  "biddingState":"APPROVED",
  "createTime":"2022-10-02T15:01:23Z"
}

C#

/* 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
 *
 *     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.PublisherConnections
{
    /// <summary>
    /// Gets a single publisher connection with a specified name.
    /// </summary>
    public class GetPublisherConnections : ExampleBase
    {
        private RealTimeBiddingService rtbService;

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

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

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

            string accountId = null;
            string publisherConnectionId = null;

            OptionSet options = new OptionSet {
                "Gets a specified publisher connection.",
                {
                    "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 " +
                     "publisher connection exists. This will be used to construct the name used " +
                     "as a path parameter for the publisherConnections.get request."),
                    a => accountId = a
                },
                {
                    "p|publisher_connection_id=",
                    ("[Required] The resource ID of the publisher connection that is being " +
                     "retrieved. This value is the publisher ID found in ads.txt or " +
                     "app-ads.txt, and is used to construct the name used as a path parameter " +
                     "for the publisherConnections.get request."),
                    p => publisherConnectionId = 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["publisher_connection_id"] = publisherConnectionId;
            // 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 publisherConnectionId = (string) parsedArgs["publisher_connection_id"];
            string name = $"bidders/{accountId}/publisherConnections/{publisherConnectionId}";

            BiddersResource.PublisherConnectionsResource.GetRequest request =
                rtbService.Bidders.PublisherConnections.Get(name);

            PublisherConnection response = null;

            Console.WriteLine("Retrieving publisher connection 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.PrintPublisherConnection(response);
        }
    }
}

Java

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

package com.google.api.services.samples.authorizedbuyers.realtimebidding.v1.bidders.publisherConnections;

import com.google.api.services.realtimebidding.v1.RealTimeBidding;
import com.google.api.services.realtimebidding.v1.model.PublisherConnection;
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 publisher connection for the given bidder.
 *
 * <p>Note: This sample will only return a populated response for bidders who are exchanges
 * participating in Open Bidding.
 */
public class GetPublisherConnections {

  public static void execute(RealTimeBidding client, Namespace parsedArgs) throws IOException {
    Long accountId = parsedArgs.getLong("account_id");
    String publisherConnectionId = parsedArgs.getString("publisher_connection_id");
    String name =
        String.format("bidders/%d/publisherConnections/%s", accountId, publisherConnectionId);

    PublisherConnection publisherConnection =
        client.bidders().publisherConnections().get(name).execute();

    System.out.printf("Get publisher connection with name \"%s\":\n", name);
    Utils.printPublisherConnection(publisherConnection);
  }

  public static void main(String[] args) {
    ArgumentParser parser =
        ArgumentParsers.newFor("GetPublisherConnections")
            .build()
            .defaultHelp(true)
            .description(
                ("Get a publisher connection for the given bidder and publisher connection IDs"));
    parser
        .addArgument("-a", "--account_id")
        .help(
            "The resource ID of the bidders resource under which the publisher connection exists. "
                + "This will be used to construct the name used as a path parameter for the "
                + "publisherConnections.get request.")
        .required(true)
        .type(Long.class);
    parser
        .addArgument("-p", "--publisher_connection_id")
        .help(
            "The resource ID of the publisher connection that is being retrieved. This value is the"
                + " publisher ID found in ads.txt or app-ads.txt, and is used to construct the name"
                + " used as a path parameter for the publisherConnections.get request.")
        .required(true);

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

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

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

/**
 * Gets a single publisher connection for the given bidder's account ID.
 *
 * Note: This sample will only return a populated response for bidders who are
 * exchanges participating in Open Bidding.
 */
class GetPublisherConnections 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 publisher ' .
                    'connection exists. This will be used to construct the name used as a path ' .
                    'parameter for the publisherConnections.get request.',
                'required' => true
            ],
            [
                'name' => 'publisher_connection_id',
                'display' => 'Publisher connection ID',
                'description' =>
                    'The resource ID of the publisher connection that is being retrieved. This ' .
                    'value is the publisher ID found in ads.txt or app-ads.txt, and is used to ' .
                    'construct the name used as a path parameter for the ' .
                    'publisherConnections.get request.',
                'required' => true,
            ]
        ];
    }

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

        print "<h2>Retrieving publisher connection with name '$name':</h2>";
        $result = $this->service->bidders_publisherConnections->get($name);
        $this->printResult($result);
    }

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

Python

#!/usr/bin/python
#
# Copyright 2022 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 publisher connection for the given bidder.

Note: This sample will only return a populated response for bidders who are
exchanges participating in Open Bidding.
"""


import argparse
import os
import pprint
import sys

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

from googleapiclient.errors import HttpError

import util


_PUBLISHER_CONNECTION_NAME_TEMPLATE = 'bidders/%s/publisherConnections/%s'

DEFAULT_BUYER_RESOURCE_ID = 'ENTER_BIDDER_RESOURCE_ID_HERE'
DEFAULT_PUBLISHER_CONNECTION_RESOURCE_ID = 'ENTER_CONNECTION_RESOURCE_ID_HERE'


def main(realtimebidding, account_id, publisher_connection_id):
  publisher_connection_name = _PUBLISHER_CONNECTION_NAME_TEMPLATE % (
      account_id, publisher_connection_id)

  print('Retrieving a publisher connection with name: '
        f'"{publisher_connection_name}".')
  try:
    response = realtimebidding.bidders().publisherConnections().get(
        name=publisher_connection_name).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('Unable to create realtimebidding service - %s' % ex)
    print('Did you specify the key file in util.py?')
    sys.exit(1)

  parser = argparse.ArgumentParser(
      description=('Get a publisher connection for the given bidder and '
                   'publisher connection IDs.'))
  # Required fields.
  parser.add_argument(
      '-a', '--account_id', default=DEFAULT_BUYER_RESOURCE_ID, required=True,
      help=('The resource ID of the bidders resource under which the '
            'publisher connection exists. This will be used to construct the '
            'name used as a path parameter for the publisherConnections.get '
            'request.'))
  parser.add_argument(
      '-p', '--publisher_connection_id',
      default=DEFAULT_PUBLISHER_CONNECTION_RESOURCE_ID, required=True,
      help=('The resource ID of the publisher connection that is being '
            'retrieved. This value is the publisher ID found in ads.txt or '
            'app-ads.txt, and is used to construct the name used as a path '
            'parameter for the publisherConnections.get request.'))

  args = parser.parse_args()

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

Ruby

#!/usr/bin/env ruby
# Encoding: utf-8
#
# Copyright:: Copyright 2022 Google LLC
#
# License:: Licensed under the Apache License, Version 2.0 (the "License");
#           you may not use this file except in compliance with the License.
#           You may obtain a copy of the License at
#
#           http://www.apache.org/licenses/LICENSE-2.0
#
#           Unless required by applicable law or agreed to in writing, software
#           distributed under the License is distributed on an "AS IS" BASIS,
#           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
#           implied.
#           See the License for the specific language governing permissions and
#           limitations under the License.
#
# Gets a single publisher connection for the given bidder.
#
# Note: This sample will only return a populated response for bidders who are
# exchanges participating in Open Bidding.

require 'optparse'

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


def get_publisher_connections(realtimebidding, options)
  name = "bidders/#{options[:account_id]}/publisherConnections/#{options[:publisher_connection_id]}"

  puts "Get publisher connection with name '#{name}'"

  publisher_connection = realtimebidding.get_bidder_publisher_connection(name)
  print_publisher_connection(publisher_connection)
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 publisher connection exists. This will be used to '\
      'construct the name used as a path parameter for the publisherConnections.get request.',
      type: Integer, short_alias: 'a', required: true, default_value: nil
    ),
    Option.new(
      'publisher_connection_id',
      'The resource ID of the publisher connection that is being retrieved. This value is the publisher ID found in '\
      'ads.txt or app-ads.txt, and is used to construct the name used as a path parameter for the '\
      'publisherConnections.get request.',
      type: String, short_alias: 'p', required: true, default_value: nil
    ),
  ]

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

  begin
    get_publisher_connections(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

List all connections

You can view all your connection requests with the list method. You can use list filters with the list method to narrow your results, for example to view connections by bidding state.

Here’s a sample list request with a filter for publisherPlatform set to GOOGLE_AD_MANAGER:

REST

Request

GET https://realtimebidding.googleapis.com/v1/bidders/{bidderId}/publisherConnections?filter=publisherPlatform+%3D+GOOGLE_AD_MANAGER

Response

{
  "publisherConnections":[
     {
        "name":"bidders/12345/publisherConnections/pub-12345",
        "publisherPlatform":"GOOGLE_AD_MANAGER",
        "displayName":"Company A",
        "biddingState":"APPROVED",
        "createTime":"2022-10-02T15:01:23Z"
     },
     {
        "name":"bidders/12345/publisherConnections/pub-23456",
        "publisherPlatform":"GOOGLE_AD_MANAGER",
        "displayName":"Company B",
        "biddingState":"APPROVED",
        "createTime":"2022-10-02T15:01:23Z"
     },
     {
        "name":"bidders/12345/publisherConnections/pub-78901",
        "publisherPlatform":"GOOGLE_AD_MANAGER",
        "displayName":"Company C",
        "biddingState":"REJECTED",
        "createTime":"2022-10-02T15:01:23Z"
     }
  ]
}

C#

/* 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
 *
 *     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.PublisherConnections
{
    /// <summary>
    /// Lists publisher connections for a given bidder account ID.
    /// </summary>
    public class ListPublisherConnections : ExampleBase
    {
        private RealTimeBiddingService rtbService;

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

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get => "This code example lists all publisher connections for a 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;
            string defaultFilter = "publisherPlatform = GOOGLE_AD_MANAGER";
            string defaultOrderBy = "createTime DESC";
            string filter = null;
            string orderBy = null;
            int? pageSize = null;

            OptionSet options = new OptionSet {
                "List publisher connections 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 " +
                     "pretargeting configurations were created. This will be used to construct " +
                     "the parent used as a path parameter for the pretargetingConfigs.list " +
                     "request."),
                    a => accountId = a
                },
                {
                    "f|filter=",
                    ("Query string to filter publisher connections. To demonstrate usage, this " +
                     "sample will default to filtering by publisherPlatform."),
                    f => filter =  f
                },
                {
                    "o|order_by=",
                    ("A string specifying the order by which results should be sorted. To " +
                     "demonstrate usage, this sample will default to ordering by createTime."),
                    o => orderBy =  o
                },
                {
                    "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["filter"] = filter ?? defaultFilter;
            parsedArgs["order_by"] = orderBy ?? defaultOrderBy;
            parsedArgs["pageSize"] = 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 publisher connections for bidder account ""{0}""", parent);
            do
            {
                BiddersResource.PublisherConnectionsResource.ListRequest request =
                   rtbService.Bidders.PublisherConnections.List(parent);
                request.Filter = (string) parsedArgs["filter"];
                request.OrderBy = (string) parsedArgs["order_by"];
                request.PageSize = (int) parsedArgs["pageSize"];
                request.PageToken = pageToken;

                ListPublisherConnectionsResponse page = null;

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

                var publisherConnections = page.PublisherConnections;
                pageToken = page.NextPageToken;

                if(publisherConnections == null)
                {
                    Console.WriteLine("No publisher connections found for bidder account.");
                }
                else
                {
                    foreach (PublisherConnection connection in publisherConnections)
                        {
                            Utilities.PrintPublisherConnection(connection);
                        }
                }
            }
            while(pageToken != null);
        }
    }
}

Java

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

package com.google.api.services.samples.authorizedbuyers.realtimebidding.v1.bidders.publisherConnections;

import com.google.api.services.realtimebidding.v1.RealTimeBidding;
import com.google.api.services.realtimebidding.v1.model.ListPublisherConnectionsResponse;
import com.google.api.services.realtimebidding.v1.model.PublisherConnection;
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 a given bidder's publisher connections.
 *
 * <p>Note: This sample will only return a populated response for bidders who are exchanges
 * participating in Open Bidding.
 */
public class ListPublisherConnections {

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

    System.out.printf("Listing publisher connections for bidder with name \"%s\":%n", parent);

    do {
      List<PublisherConnection> publisherConnections = null;

      ListPublisherConnectionsResponse response = client
          .bidders()
          .publisherConnections()
          .list(parent)
          .setPageSize(pageSize)
          .setPageToken(pageToken)
          .execute();

      publisherConnections = response.getPublisherConnections();
      pageToken = response.getNextPageToken();

      if (publisherConnections == null) {
        System.out.println("No publisher connections found.");
      } else {
        for (PublisherConnection publisherConnection : publisherConnections) {
          Utils.printPublisherConnection(publisherConnection);
        }
      }
    } while (pageToken != null);
  }

  public static void main(String[] args) {
    ArgumentParser parser =
        ArgumentParsers.newFor("ListPublisherConnections")
            .build()
            .defaultHelp(true)
            .description("Lists publisher connections associated with the given bidder account.");
    parser
        .addArgument("-a", "--account_id")
        .help(
            "The number of rows to return per page. The server may return fewer rows than "
                + "specified.")
        .required(true)
        .type(Long.class);
    parser
        .addArgument("-f", "--filter")
        .help(
            "Query string to filter publisher connections. To demonstrate usage, this sample "
                + "will default to filtering by publisherPlatform.")
        .setDefault("publisherPlatform = GOOGLE_AD_MANAGER");
    parser
        .addArgument("-o", "--order_by")
        .help(
            "A string specifying the order by which results should be sorted. To demonstrate "
                + "usage, this sample will default to ordering by createTime.")
        .setDefault("createTime DESC");
    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 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.
 */

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

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

/**
 * Lists publisher connections for a given bidder account ID.
 *
 * Note: This sample will only return a populated response for bidders who are
 * exchanges participating in Open Bidding.
 */
class ListPublisherConnections extends BaseExample
{
    public function __construct($client)
    {
        $this->service = Config::getGoogleServiceRealTimeBidding($client);
    }

    /**
     * @see BaseExample::getInputParameters()
     */
    protected function getInputParameters()
    {
        return [
            [
                'name' => 'account_id',
                'display' => 'Bidder account ID',
                'required' => true,
                'description' =>
                    'The resource ID of the bidders resource under which the publisher ' .
                    'connections exist. This will be used to construct the parent ' .
                    'used as a path parameter for the publisherConnections.list request.'
            ],
            [
                'name' => 'filter',
                'display' => 'Filter',
                'required' => false,
                'description' =>
                    'Query string used to filter publisher connections. To demonstrate usage, ' .
                    'this sample will default to filtering by publisherPlatform.',
                'default' => 'publisherPlatform = GOOGLE_AD_MANAGER'
            ],
            [
                'name' => 'order_by',
                'display' => 'Order by',
                'required' => false,
                'description' =>
                    'A string specifying the order by which results should be sorted. To ' .
                    'demonstrate usage, this sample will default to ordering by createTime.',
                'default' => 'createTime DESC'
            ],
            [
                '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 = [
            'filter' => $values['filter'],
            'orderBy' => $values['order_by'],
            'pageSize' => $values['page_size']
        ];

        $result = $this->service->bidders_publisherConnections->listBiddersPublisherConnections(
            $parentName,
            $queryParams
        );

        print "<h2>Publisher connections found for '$parentName':</h2>";
        if (empty($result['publisherConnections'])) {
            print '<p>No publisher connections found</p>';
        } else {
            foreach ($result['publisherConnections'] as $publisherConnection) {
                $this->printResult($publisherConnection);
            }
        }
    }

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

Python

#!/usr/bin/python
#
# Copyright 2022 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 a bidder's publisher connections.

Note: This sample will only return a populated response for bidders who are
exchanges participating in Open Bidding.
"""


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_token = None
  more_pages = True

  print('Listing publisher connections for bidder account: '
        f'"{account_id}".')
  while more_pages:
    try:
      # Construct and execute the request.
      response = realtimebidding.bidders().publisherConnections().list(
          parent=_BIDDER_NAME_TEMPLATE % account_id, pageToken=page_token,
          pageSize=args.page_size, filter=args.filter,
          orderBy=args.order_by).execute()
    except HttpError as e:
      print(e)
      sys.exit(1)

    pprint.pprint(response)

    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 publisher connections 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 publisher '
            'connections exist. This will be used to construct the parent used '
            'as a path parameter for the publisherConnections.list request.'))
  # Optional fields.
  parser.add_argument(
      '-f', '--filter', default='publisherPlatform = GOOGLE_AD_MANAGER',
      help=('Query string used to filter publisher connections. To demonstrate '
            'usage, this sample will default to filtering by publisherPlatform.'
            ))
  parser.add_argument(
      '-o', '--order_by', default='createTime DESC',
      help=('A string specifying the order by which results should be sorted. '
            'To demonstrate usage, this sample will default to ordering by '
            'createTime.'))
  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 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.
#
# Lists a bidder's publisher connections.
#
# Note: This sample will only return a populated response for bidders who are
# exchanges participating in Open Bidding.

require 'optparse'

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


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

  page_token = nil

  puts "Listing publisher connections for bidder with name '#{parent}'"
  begin
    response = realtimebidding.list_bidder_publisher_connections(
        parent,
        filter: filter,
        order_by: order_by,
        page_size: page_size,
        page_token: page_token,
    )

    page_token = response.next_page_token

    unless response.publisher_connections.nil?
      response.publisher_connections.each do |publisher_connection|
        print_publisher_connection(publisher_connection)
      end
    else
      puts 'No publisher connections found for buyer account'
    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 publisher connections exist. This will be used to '\
      'construct the parent used as a path parameter for the publisherConnections.list request.',
      type: Integer, short_alias: 'a', required: true, default_value: nil
    ),
    Option.new(
      'filter',
      'Query string used to filter publisher connections. To demonstrate usage, this sample will default to '\
      'filtering by publisherPlatform.',
      type: String, short_alias: 'f', required: false, default_value: 'publisherPlatform = GOOGLE_AD_MANAGER'
    ),
    Option.new(
      'order_by',
      'A string specifying the order by which results should be sorted. To demonstrate usage, this sample will '\
      'default to ordering by createTime.',
      type: String, short_alias: 'o', required: false, default_value: 'createTime DESC'
    ),
    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_publisher_connections(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

In this example, there are only a small number of connections returned by the list call. For short responses, the entire set of connections is returned instead of paginated results with nextPageToken.

Approve requests

You can use batchApprove to approve one or more publisher connection requests. You can approve new and previously rejected requests. We recommend you only approve connections with publishers you want to receive bid requests from, after signing a contract. This method returns the PublisherConnection objects you approved.

Here’s a sample batchApprove request:

REST

Request

POST https://realtimebidding.googleapis.com/v1/bidders/{bidderId}/publisherConnections:batchApprove

{
 "names": [
   "bidders/12345/publisherConnections/pub-12345",
   "bidders/12345/publisherConnections/pub-23456"
 ]
}

Response

{
 "publisherConnections":[
   {
     "name":"bidders/12345/publisherConnections/pub-12345",
     "publisherPlatform":"GOOGLE_AD_MANAGER",
     "displayName":"Company A",
     "biddingState":"APPROVED",
     "createTime":"2022-10-02T15:01:23Z"
   },
   {
     "name":"bidders/12345/publisherConnections/pub-23456",
     "publisherPlatform":"GOOGLE_AD_MANAGER",
     "displayName":"Company B",
     "biddingState":"APPROVED",
     "createTime":"2022-10-02T15:01:23Z"
   }
 ]
}

C#

/* 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
 *
 *     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.PublisherConnections
{
    /// <summary>
    /// Batch approves one or more publisher connections.
    ///
    /// Approving a publisher connection means that the bidder agrees to receive bid requests from
    /// the publisher.
    /// </summary>
    public class BatchApprovePublisherConnections : ExampleBase
    {
        private RealTimeBiddingService rtbService;

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

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get => "This code example batch approves one or more publisher connections.";
        }

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

            string accountId = null;
            IList<string> publisherConnectionIds = new List<string>();

            OptionSet options = new OptionSet {
                "Batch approves one or more publisher connections to a 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 for which the " +
                     "publisher connections are being approved."),
                    a => accountId = a
                },
                {
                    "p|publisher_connection_ids=",
                    ("[Required] One or more resource IDs for the bidders.publisherConnections " +
                     "resource that are being approved. Specify this argument for each value " +
                     "you intend to include. Values specified must be valid URLs. These will be " +
                     "used to construct the publisher connection names passed in the " +
                     "publisherConnections.batchApprove request body"),
                    p => publisherConnectionIds.Add(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["publisher_connection_ids"] =
                publisherConnectionIds.Count > 0 ? publisherConnectionIds : null;
            // 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}";

            IList<string> publisherConnectionIds =
                (IList<string>) parsedArgs["publisher_connection_ids"];
            IList<string> publisherConnectionNames = new List<string>();

            foreach (string publisherConnectionId in publisherConnectionIds)
            {
                publisherConnectionNames.Add(
                    $"bidders/{accountId}/publisherConnections/{publisherConnectionId}");
            }

            BatchApprovePublisherConnectionsRequest body =
                new BatchApprovePublisherConnectionsRequest();
            body.Names = publisherConnectionNames;

            BiddersResource.PublisherConnectionsResource.BatchApproveRequest request =
                rtbService.Bidders.PublisherConnections.BatchApprove(body, parent);
            BatchApprovePublisherConnectionsResponse response = null;

            Console.WriteLine(
                "Batch approving publisher connections for bidder with name: {0}",
                parent);

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

            foreach (PublisherConnection publisherConnection in response.PublisherConnections)
            {
                Utilities.PrintPublisherConnection(publisherConnection);
            }
        }
    }
}

Java

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

package com.google.api.services.samples.authorizedbuyers.realtimebidding.v1.bidders.publisherConnections;

import com.google.api.services.realtimebidding.v1.RealTimeBidding;
import com.google.api.services.realtimebidding.v1.model.BatchApprovePublisherConnectionsRequest;
import com.google.api.services.realtimebidding.v1.model.BatchApprovePublisherConnectionsResponse;
import com.google.api.services.realtimebidding.v1.model.PublisherConnection;
import com.google.api.services.samples.authorizedbuyers.realtimebidding.Utils;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.ArrayList;
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;

/**
 * Batch approves one or more publisher connections.
 *
 * <p>Approving a publisher connection means that the bidder agrees to receive bid requests from the
 * publisher.
 */
public class BatchApprovePublisherConnections {

  public static void execute(RealTimeBidding client, Namespace parsedArgs) throws IOException {
    Long bidderAccountId = parsedArgs.getLong("account_id");
    String parent = String.format("bidders/%d", bidderAccountId);

    String publisherConnectionNameTemplate = "bidders/%d/publisherConnections/%s";
    List<String> publisherConnectionIds = parsedArgs.getList("publisher_connection_ids");
    List<String> publisherConnectionNames = new ArrayList<>(publisherConnectionIds.size());

    // Populate list of publisher connection names that are to be approved.
    for (String publisherConnectionId : publisherConnectionIds) {
      publisherConnectionNames.add(
          String.format(publisherConnectionNameTemplate, bidderAccountId, publisherConnectionId));
    }

    // Set list of publisher connection names to the API request body.
    BatchApprovePublisherConnectionsRequest body = new BatchApprovePublisherConnectionsRequest();
    body.setNames(publisherConnectionNames);

    System.out.printf("Batch approving publisher connections for bidder with name: '%s'\n", parent);

    BatchApprovePublisherConnectionsResponse batchApprovePublisherConnectionsResponse =
        client.bidders().publisherConnections().batchApprove(parent, body).execute();

    for (PublisherConnection publisherConnection :
        batchApprovePublisherConnectionsResponse.getPublisherConnections()) {
      Utils.printPublisherConnection(publisherConnection);
    }
  }

  public static void main(String[] args) {
    ArgumentParser parser =
        ArgumentParsers.newFor("BatchApprovePublisherConnections")
            .build()
            .defaultHelp(true)
            .description(
                ("Batch approves one or more publisher connections to a given bidder account."));
    parser
        .addArgument("-a", "--account_id")
        .help(
            "The resource ID of the bidders resource for which the publisher connections are "
                + "being approved.")
        .required(true)
        .type(Long.class);
    parser
        .addArgument("-p", "--publisher_connection_ids")
        .help(
            "One or more resource IDs for the bidders.publisherConnections resource that are "
                + "being approved. Specify each ID separated by a space. These will be used to "
                + "construct the publisher connection names passed in the "
                + "publisherConnections.batchApprove request body.")
        .required(true)
        .nargs("+");

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

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

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

/**
 * Batch approves one or more publisher connections.
 *
 * Approving a publisher connection means that the bidder agrees to receive
 * bid requests from the publisher.
 */
class BatchApprovePublisherConnections 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 publisher ' .
                    'connections exist. This will be used to construct the parent used as a ' .
                    'path parameter for the publisherConnections.batchApprove request, as well ' .
                    'as the publisher connection names passed in the request body.',
                'required' => true
            ],
            [
                'name' => 'publisher_connection_ids',
                'display' => 'Publisher connection IDs',
                'description' =>
                    'One or more resource IDs for the bidders.publisherConnections resource ' .
                    'that are being approved. Specify each value separated by a comma. These ' .
                    'will be used to construct the publisher connection names passed in the ' .
                    'publisherConnections.batchApprove request body.',
                'required' => true,
                'is_array' => true
            ]
        ];
    }

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

        $pubConnIds = $values[publisher_connection_ids];
        $batchApproveRequest = new Google_Service_RealTimeBidding_BatchApprovePublisherConnectionsRequest();
        $batchApproveRequest->names = array_map(
            function ($pubConnId) use ($accountId) {
                    return "$parent/publisherConnections/$pubConnId";
            },
            $pubConnIds
        );

        print "<h2>Batch approving publisher connections for bidder with name: \"$parent\":";
        $result = $this->service->bidders_publisherConnections->batchApprove(
            $parent,
            $batchApproveRequest
        );
        $this->printResult($result);
    }

    /**
     * @see BaseExample::getName()
     */
    public function getName()
    {
        return 'Batch Approve Publisher Connections';
    }
}

Python

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

"""Batch approves one or more publisher connections.

Approving a publisher connection means that the bidder agrees to receive bid
requests from the publisher.
"""


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'
_PUBLISHER_CONNECTION_NAME_TEMPLATE = 'bidders/%s/publisherConnections/%s'

DEFAULT_BUYER_RESOURCE_ID = 'ENTER_BIDDER_RESOURCE_ID_HERE'


def main(realtimebidding, args):
  account_id = args.account_id
  parent = _BIDDER_NAME_TEMPLATE % account_id

  body = {
      "names": [
          _PUBLISHER_CONNECTION_NAME_TEMPLATE % (
              account_id, publisher_connection_id)
          for publisher_connection_id in args.publisher_connection_ids
      ]
  }

  print('Batch approving publisher connections for bidder with name: '
        f'"{parent}".')
  try:
    response = realtimebidding.bidders().publisherConnections().batchApprove(
        parent=parent, body=body).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('Unable to create realtimebidding service - %s' % ex)
    print('Did you specify the key file in util.py?')
    sys.exit(1)

  parser = argparse.ArgumentParser(
      description='Batch approves one or more publisher connections.')
  # Required fields.
  parser.add_argument(
      '-a', '--account_id', default=DEFAULT_BUYER_RESOURCE_ID,
      help=('The resource ID of the bidders resource under which the '
            'publisher connections exist. This will be used to construct the '
            'parent used as a path parameter for the '
            'publisherConnections.batchApprove request, as well as the '
            'publisher connection names passed in the request body.'))
  parser.add_argument(
      '-p', '--publisher_connection_ids', nargs='+', required=True,
      help=('One or more resource IDs for the bidders.publisherConnections '
            'resource that are being approved. Specify each value separated by '
            'a space. These will be used to construct the publisher connection '
            'names passed in the publisherConnections.batchApprove request '
            'body.'))

  args = parser.parse_args()

  main(service, args)

Ruby

#!/usr/bin/env ruby
# Encoding: utf-8
#
# Copyright:: Copyright 2022 Google LLC
#
# License:: Licensed under the Apache License, Version 2.0 (the "License");
#           you may not use this file except in compliance with the License.
#           You may obtain a copy of the License at
#
#           http://www.apache.org/licenses/LICENSE-2.0
#
#           Unless required by applicable law or agreed to in writing, software
#           distributed under the License is distributed on an "AS IS" BASIS,
#           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
#           implied.
#           See the License for the specific language governing permissions and
#           limitations under the License.
#
# Batch approves one or more publisher connections.
#
# Approving a publisher connection means that the bidder agrees to receive bid
# requests from the publisher.

require 'optparse'

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


def batch_approve_publisher_connections(realtimebidding, options)
  account_id = options[:account_id]
  parent = "bidders/#{account_id}"
  publisher_connection_names = options[:publisher_connection_ids].map{
      |publisher_connection_id| "bidders/#{account_id}/publisherConnections/#{publisher_connection_id}"}

  puts "Batch approving publisher connections for bidder with name: '#{parent}'"

  body = Google::Apis::RealtimebiddingV1::BatchApprovePublisherConnectionsRequest.new(
    names: publisher_connection_names
  )

  response = realtimebidding.batch_approve_publisher_connections(parent, body)

  unless response.publisher_connections.nil?
    response.publisher_connections.each do |publisher_connection|
      print_publisher_connection(publisher_connection)
    end
  end
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 publisher connections exist. This will be used to '\
      'construct the parent used as a path parameter for the publisherConnections.batchApprove request, as well as '\
      'the publisher connection names passed in the request body.',
      type: Integer, short_alias: 'a', required: true, default_value: nil
    ),
    Option.new(
      'publisher_connection_ids',
      'One or more resource IDs for the bidders.publisherConnections resource that are being approved. Specify each '\
      'value separated by a comma. These will be used to construct the publisher connection names passed in the '\
      'publisherConnections.batchApprove request body.',
      type: Array, short_alias: 'p', required: true, default_value: nil
    ),
  ]

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

  begin
    batch_approve_publisher_connections(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

Reject requests

You can use batchReject to reject one or more publisher connection requests. You can reject new and previously approved requests. This method returns the PublisherConnection objects you rejected.

Here’s a sample batchReject request:

REST

Request

POST https://realtimebidding.googleapis.com/v1/bidders/{bidderId}/publisherConnections:batchReject

{
 "names":[
   "bidders/12345/publisherConnections/pub-12345",
   "bidders/12345/publisherConnections/pub-23456"
 ]
}

Response

{
  "publisherConnections":[
    {
      "name":"bidders/12345/publisherConnections/pub-12345",
      "publisherPlatform":"GOOGLE_AD_MANAGER",
      "displayName":"Company A",
      "biddingState":"REJECTED",
      "createTime":"2022-10-02T15:01:23Z"
    },
    {
      "name":"bidders/12345/publisherConnections/pub-23456",
      "publisherPlatform":"GOOGLE_AD_MANAGER",
      "displayName":"Company B",
      "biddingState":"REJECTED",
      "createTime":"2022-10-02T15:01:23Z"
   }
 ]
}

C#

/* 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
 *
 *     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.PublisherConnections
{
    /// <summary>
    /// Batch rejects one or more publisher connections.
    ///
    /// A bidder will not receive bid requests from publishers associated with rejected publisher
    /// connections.
    /// </summary>
    public class BatchRejectPublisherConnections : ExampleBase
    {
        private RealTimeBiddingService rtbService;

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

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get => "This code example batch rejects one or more publisher connections.";
        }

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

            string accountId = null;
            IList<string> publisherConnectionIds = new List<string>();

            OptionSet options = new OptionSet {
                "Batch rejects one or more publisher connections to a 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 for which the " +
                     "publisher connections are being rejected."),
                    a => accountId = a
                },
                {
                    "p|publisher_connection_ids=",
                    ("[Required] One or more resource IDs for the bidders.publisherConnections " +
                     "resource that are being rejected. Specify this argument for each value " +
                     "you intend to include. Values specified must be valid URLs. These will be " +
                     "used to construct the publisher connection names passed in the " +
                     "publisherConnections.batchReject request body"),
                    p => publisherConnectionIds.Add(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["publisher_connection_ids"] =
                publisherConnectionIds.Count > 0 ? publisherConnectionIds : null;
            // 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}";

            IList<string> publisherConnectionIds =
                (IList<string>) parsedArgs["publisher_connection_ids"];
            IList<string> publisherConnectionNames = new List<string>();

            foreach (string publisherConnectionId in publisherConnectionIds)
            {
                publisherConnectionNames.Add(
                    $"bidders/{accountId}/publisherConnections/{publisherConnectionId}");
            }

            BatchRejectPublisherConnectionsRequest body =
                new BatchRejectPublisherConnectionsRequest();
            body.Names = publisherConnectionNames;

            BiddersResource.PublisherConnectionsResource.BatchRejectRequest request =
                rtbService.Bidders.PublisherConnections.BatchReject(body, parent);
            BatchRejectPublisherConnectionsResponse response = null;

            Console.WriteLine(
                "Batch rejecting publisher connections for bidder with name: {0}",
                parent);

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

            foreach (PublisherConnection publisherConnection in response.PublisherConnections)
            {
                Utilities.PrintPublisherConnection(publisherConnection);
            }
        }
    }
}

Java

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

package com.google.api.services.samples.authorizedbuyers.realtimebidding.v1.bidders.publisherConnections;

import com.google.api.services.realtimebidding.v1.RealTimeBidding;
import com.google.api.services.realtimebidding.v1.model.BatchRejectPublisherConnectionsRequest;
import com.google.api.services.realtimebidding.v1.model.BatchRejectPublisherConnectionsResponse;
import com.google.api.services.realtimebidding.v1.model.PublisherConnection;
import com.google.api.services.samples.authorizedbuyers.realtimebidding.Utils;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.ArrayList;
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;

/**
 * Batch rejects one or more publisher connections.
 *
 * <p>A bidder will not receive bid requests from publishers associated with rejected publisher
 * connections.
 */
public class BatchRejectPublisherConnections {

  public static void execute(RealTimeBidding client, Namespace parsedArgs) throws IOException {
    Long bidderAccountId = parsedArgs.getLong("account_id");
    String parent = String.format("bidders/%d", bidderAccountId);

    String publisherConnectionNameTemplate = "bidders/%d/publisherConnections/%s";
    List<String> publisherConnectionIds = parsedArgs.getList("publisher_connection_ids");
    List<String> publisherConnectionNames = new ArrayList<>(publisherConnectionIds.size());

    for (String publisherConnectionId : publisherConnectionIds) {
      publisherConnectionNames.add(
          String.format(publisherConnectionNameTemplate, bidderAccountId, publisherConnectionId));
    }

    BatchRejectPublisherConnectionsRequest body = new BatchRejectPublisherConnectionsRequest();
    body.setNames(publisherConnectionNames);

    System.out.printf("Batch rejecting publisher connections for bidder with name: '%s'\n", parent);

    BatchRejectPublisherConnectionsResponse batchRejectPublisherConnectionsResponse =
        client.bidders().publisherConnections().batchReject(parent, body).execute();

    for (PublisherConnection publisherConnection :
        batchRejectPublisherConnectionsResponse.getPublisherConnections()) {
      Utils.printPublisherConnection(publisherConnection);
    }
  }

  public static void main(String[] args) {
    ArgumentParser parser =
        ArgumentParsers.newFor("BatchRejectPublisherConnections")
            .build()
            .defaultHelp(true)
            .description(
                ("Batch rejects one or more publisher connections from a given bidder account."));
    parser
        .addArgument("-a", "--account_id")
        .help(
            "The resource ID of the bidders resource for which the publisher connections are "
                + "being rejected.")
        .required(true)
        .type(Long.class);
    parser
        .addArgument("-p", "--publisher_connection_ids")
        .help(
            "One or more resource IDs for the bidders.publisherConnections resource that are "
                + "being rejected. Specify each ID separated by a space. These will be used to "
                + "construct the publisher connection names passed in the "
                + "publisherConnections.batchReject request body.")
        .required(true)
        .nargs("+");

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

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

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

/**
 * Batch rejects one or more publisher connections.
 *
 * A bidder will not receive bid requests from publishers associated with
 * rejected publisher connections.
 */
class BatchRejectPublisherConnections 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 publisher ' .
                    'connections exist. This will be used to construct the parent used as a ' .
                    'path parameter for the publisherConnections.batchReject request, as well ' .
                    'as the publisher connection names passed in the request body.',
                'required' => true
            ],
            [
                'name' => 'publisher_connection_ids',
                'display' => 'Publisher connection IDs',
                'description' =>
                    'One or more resource IDs for the bidders.publisherConnections resource ' .
                    'that are being rejected. Specify each value separated by a comma. These ' .
                    'will be used to construct the publisher connection names passed in the ' .
                    'publisherConnections.batchReject request body.',
                'required' => true,
                'is_array' => true
            ]
        ];
    }

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

        $pubConnIds = $values[publisher_connection_ids];
        $batchRejectRequest = new Google_Service_RealTimeBidding_BatchRejectPublisherConnectionsRequest();
        $batchRejectRequest->names = array_map(
            function ($pubConnId) use ($accountId) {
                    return "$parent/publisherConnections/$pubConnId";
            },
            $pubConnIds
        );

        print "<h2>Batch rejecting publisher connections for bidder with name: \"$parent\":";
        $result = $this->service->bidders_publisherConnections->batchReject(
            $parent,
            $batchRejectRequest
        );
        $this->printResult($result);
    }

    /**
     * @see BaseExample::getName()
     */
    public function getName()
    {
        return 'Batch Reject Publisher Connections';
    }
}

Python

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

"""Batch rejects one or more publisher connections.

A bidder will not receive bid requests from publishers associated with rejected
publisher connections.
"""


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'
_PUBLISHER_CONNECTION_NAME_TEMPLATE = 'bidders/%s/publisherConnections/%s'

DEFAULT_BUYER_RESOURCE_ID = 'ENTER_BIDDER_RESOURCE_ID_HERE'


def main(realtimebidding, args):
  account_id = args.account_id
  parent = _BIDDER_NAME_TEMPLATE % account_id

  body = {
      "names": [
          _PUBLISHER_CONNECTION_NAME_TEMPLATE % (
              account_id, publisher_connection_id)
          for publisher_connection_id in args.publisher_connection_ids
      ]
  }

  print('Batch rejecting publisher connections for bidder with name: '
        f'"{parent}".')
  try:
    response = realtimebidding.bidders().publisherConnections().batchReject(
        parent=parent, body=body).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('Unable to create realtimebidding service - %s' % ex)
    print('Did you specify the key file in util.py?')
    sys.exit(1)

  parser = argparse.ArgumentParser(
      description='Batch rejects one or more publisher connections.')
  # Required fields.
  parser.add_argument(
      '-a', '--account_id', default=DEFAULT_BUYER_RESOURCE_ID,
      help=('The resource ID of the bidders resource under which the '
            'publisher connections exist. This will be used to construct the '
            'parent used as a path parameter for the '
            'publisherConnections.batchReject request, as well as the '
            'publisher connection names passed in the request body.'))
  parser.add_argument(
      '-p', '--publisher_connection_ids', nargs='+', required=True,
      help=('One or more resource IDs for the bidders.publisherConnections '
            'resource that are being rejected. Specify each value separated by '
            'a space. These will be used to construct the publisher connection '
            'names passed in the publisherConnections.batchReject request '
            'body.'))

  args = parser.parse_args()

  main(service, args)

Ruby

#!/usr/bin/env ruby
# Encoding: utf-8
#
# Copyright:: Copyright 2022 Google LLC
#
# License:: Licensed under the Apache License, Version 2.0 (the "License");
#           you may not use this file except in compliance with the License.
#           You may obtain a copy of the License at
#
#           http://www.apache.org/licenses/LICENSE-2.0
#
#           Unless required by applicable law or agreed to in writing, software
#           distributed under the License is distributed on an "AS IS" BASIS,
#           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
#           implied.
#           See the License for the specific language governing permissions and
#           limitations under the License.
#
# Batch rejects one or more publisher connections.
#
# A bidder will not receive bid requests from publishers associated with
# rejected publisher connections.

require 'optparse'

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


def batch_reject_publisher_connections(realtimebidding, options)
  account_id = options[:account_id]
  parent = "bidders/#{account_id}"
  publisher_connection_names = options[:publisher_connection_ids].map{
      |publisher_connection_id| "bidders/#{account_id}/publisherConnections/#{publisher_connection_id}"}

  puts "Batch rejecting publisher connections for bidder with name: '#{parent}'"

  body = Google::Apis::RealtimebiddingV1::BatchRejectPublisherConnectionsRequest.new(
    names: publisher_connection_names
  )

  response = realtimebidding.batch_reject_publisher_connections(parent, body)

  unless response.publisher_connections.nil?
    response.publisher_connections.each do |publisher_connection|
      print_publisher_connection(publisher_connection)
    end
  end
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 publisher connections exist. This will be used to '\
      'construct the parent used as a path parameter for the publisherConnections.batchReject request, as well as '\
      'the publisher connection names passed in the request body.',
      type: Integer, short_alias: 'a', required: true, default_value: nil
    ),
    Option.new(
      'publisher_connection_ids',
      'One or more resource IDs for the bidders.publisherConnections resource that are being rejected. Specify each '\
      'value separated by a comma. These will be used to construct the publisher connection names passed in the '\
      'publisherConnections.batchReject request body.',
      type: Array, short_alias: 'p', required: true, default_value: nil
    ),
  ]

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

  begin
    batch_reject_publisher_connections(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