FLEDGE simulation experiment for RTB partners

As part of the Privacy Sandbox, Chrome proposed FLEDGE: an in-browser API aimed to allow advertisers and ad tech companies to show interest group-targeted ads without relying on third-party cookies, thus protecting users from cross-site tracking. Google offers a server-side FLEDGE simulation that allows its RTB partners (Authorized Buyers) to experiment with the flows similar to those in Chrome's FLEDGE proposal. The simulation allows partners and Google to iterate on and learn about the efficacy of FLEDGE-style flows, to generate relevant feedback on potential API improvements in public forums (for example, GitHub), and to better prepare for the transition to supporting personalized advertising without relying on third-party cookies.

In the current phase of the simulation, bidders host interest group memberships. Bidders also provide bidding functions to Google ahead of time through an API. At serving time, Google splits each bid request in scope for the simulation into two requests: a contextual request and an interest-based request. The contextual request will be similar to the non-experimental bid requests but with user identifiers (such as google_user_id or hosted_match_data) redacted.

Interest group bid requests do not contain any contextual information and would contain only pseudonymous user identifiers (subject to the existing privacy protections and controls), as well as a small subset of other essential fields. Interest group bids returned by a bidder in the simulation do not specify a bid CPM value, but instead reference a bidding function that Google runs server-side in a sandboxed environment. The bidding function computes the bid value and can select an ad from one of those specified by the bidder in the response to an interest-based bid request.

The presence of user identifiers in interest-based requests is subject to the existing privacy protections and controls–such as when a user opts out of personalized advertising.

FLEDGE simulation vs TURTLEDOVE simulation

Earlier TURTLEDOVE simulation was inspired by the original TURTLEDOVE proposal. The FLEDGE simulation experiment described in this guide is based on the more recent FLEDGE proposal. The main changes include:

  • One bidding function invocation for each simulated interest group: in the TURTLEDOVE simulation, the bidder can specify a separate bidding function to run for each interest group bid (ad) in the bid response. In the FLEDGE simulation, a bidder can request to execute one bidding function for a logical collection of ads in the bid response.
  • Bidding function may select an ad: in the TURTLEDOVE simulation, the bidding function returns only a single bid value for each interest group ad. In the FLEDGE simulation, the bidding function can choose an ad (potentially out of multiple logically related ads in the bid response) and return a bid value.
  • Bidding function input arguments: the bidding function input arguments are updated to align closer with the FLEDGE proposal. See the new bidding function input in the Bidding Functions section.
  • The bidding function may populate an optional debug string that may be used for remote debugging and troubleshooting of a bidder-provided bidding function. The debug string should not contain a user identifier. The maximum length of the debug string is 200 bytes. This debug string is available in BidResponseFeedback and BidFeedback, for the Google protocol and OpenRTB protocol respectively. In addition, the debug string can be inserted into the creative HTML snippet via macro substitution if the following string is included in the snippet: “%%DEBUG_STRING%%”. Please ensure the debug string complies with Platform Program Policies.

Flow

  1. A bidder works with advertisers to create, maintain, and host interest groups for each advertiser.

  2. A bidder provides one or more bidding functions (as side effect-free JavaScript functions) ahead of time. (See section: Bidding functions).

  3. When the user visits a publisher webpage, the user's browser will download Google's publisher ad tag, which makes a request to serve an ad.

  4. For the small fraction of requests in scope for the experiment, Google sends separate simulated contextual bid requests and interest-based bid requests to each bidder participating in the experiment (See section: Bid requests).

  5. The bidder uses the pseudonymous user ID available in the interest group bid request and maps it to the corresponding interest groups. The RTB bidder returns bid responses to the simulated contextual and interest group requests (See section: Bid responses).

    1. Contextual bid responses will be similar to non-experimental bid response with zero or more contextual bids; in addition to that, the contextual bid response can carry bidder custom contextual signals (per_buyer_signals) that will be used only as inputs to a bidding function.
    2. Responses to the simulated interest-based requests will contain one or more bids, each associated with an ad. These bids will not specify a bid value. Logically related ads (for instance, pertaining to the same interest group hosted by a bidder) can be grouped together in the bid response. A bidder specifies the name of the bidding function to use with each such logical group of ads in the response. The bidding function will choose an ad from one or more specified in the bid response and compute a bid for the chosen ad.
  6. Google runs a regular server-side auction with the following candidates:

    1. Bids from the contextual response.
    2. Bids from the interest group response with the ads chosen and bid prices computed by running the bidding functions.
    3. Regular bids from other bidders.
  7. A winning ad is returned to the user's browser and can be rendered normally.

Bidding functions

Bidding functions are functions provided by the bidders that will return a bid value for a given interest group-based ad and an ad slot. In the FLEDGE proposal, this function would be executed by the user's browser. In the simulation, bidders can upload the bidding functions using Bidding function upload API ahead of time. At serving time, the interest group bid response can contain one or more requests (for a logical set of one or more ads) to execute a bidding function with the specified name and inputs. Google will execute the bidding function in a sandboxed server-side environment to get a bid value and a chosen ad. This computed bid value can enter the auction in the same way as a regular bid.

Bidding function interface

The bidding function should be a pure, side-effect free function implemented in JavaScript that will be run in a server-side sandbox. A bidding function does not have access to the network, storage or any other forms of I/O or external resources and cannot retain any state between invocations for different bid requests. The bidding function selects an ad candidate among ads from the interest-based bid response and returns a bid price CPM for that ad candidate.

A bidding function must accept and run with an empty object as its input parameter–an empty input is provided to bidding functions to allow for one-time initialization, if such initialization were expensive.

See additional documentation.

/**
 * Returns a bid price CPM for a given ad candidate.
 *
 * @param {Object} inputs an object with the
 *                 following named fields:
 *                   - interestGroup
 *                   - auctionSignals
 *                   - perBuyerSignals
 *                   - trustedBiddingSignals
 *                   - browserSignals
 */
function(inputs) {
  ...
  return {
    'buyerCreativeId': 'ad_creative_id_1',
    'bidPriceCpm': 0.3,
    'productIds': ['product_id_1', 'product_id_2', 'product_id_3'],
    'debugString': 'Bidding function executed successfully!'
  }
}

Named fields in inputs Object argument include (subject to change as the experiment progresses):

Field Name Description
interestGroup A JSON object containing a list of ad objects, which contain the following named fields:
  • buyerCreativeId: The ad creative ID string.
  • adData: JSON object; will be populated from BidResponse.ad.adslot.ad_data for the Google Authorized Buyers protocol and BidResponse.seatbid.bid.ext.ad_data for the OpenRTB protocol.
  • userBiddingSignals: JSON object; will be populated from BidResponse.interest_group_map.user_bidding_signals for Google Authorized Buyers protocol and BidResponse.ext.interest_group_map.user_bidding_signals for the OpenRTB protocol.

    Example:

    "interestGroup" : {
         "ad" : [
             {
               "buyerCreativeId": "...",   // Ad creative ID
               "adData": { // JSON object
               }
             }
          ],
          "userBiddingSignals": {
            // JSON object
          }
    }
    
auctionSignals Contains simulated signals from the exchange. An object containing the following named fields:
  • url: The string URL of the page with parameters removed.
  • slotVisibility: Enum of one of the following potential values:
    • NO_DETECTION = 0
    • ABOVE_THE_FOLD = 1
    • BELOW_THE_FOLD = 2
  • slotDimensions: A list of objects containing width and height pairs from BidRequest.adslot.width and BidRequest.adslot.height for the Google Authorized Buyers protocol and BidRequest.imp.banner.format.w and BidRequest.imp.banner.format.h for the OpenRTB protocol.
perBuyerSignals JSON object from the contextual bid response populated with BidResponse.interest_group_bidding.interest_group_buyers.per_buyer_signals for the Google Authorized Buyers protocol and BidResponse.ext.interest_group_bidding.interest_group_buyers.per_buyer_signals for the OpenRTB protocol.
trustedBiddingSignals JSON object from the interest group bid response populated with BidResponse.interest_group_map.trusted_bidding_signals for the Google Authorized Buyers protocol and BidResponse.ext.interest_group_map.trusted_bidding_signals for the OpenRTB protocol.
browserSignals Not populated yet.

API management of bidding functions

The Real-time Bidding API has an experimental biddingFunctions resource that allows bidders to upload bidding functions to Google and manage these functions.

Base Service Endpoint: https://realtimebidding.googleapis.com

Bidding function resource

{
  "name": string,
  "biddingFunction": string
  "type": enum (FunctionType)
}

The field name represents the name of the bidding function. It should follow the format: bidders/{bidderAccountId}/biddingFunctions/{biddingFunctionName}, where biddingFunctionName is chosen by a bidder. type field indicates whether the bidding function is FLEDGE_BIDDING_FUNCTION, for the function interface described in this document or TURTLEDOVE_SIMULATION_BIDDING_FUNCTION for the interface described in TURTLEDOVE RTB Simulation API.

The field biddingFunction is the JavaScript source code of the bidding function, with the following requirements:

  • Size of <5 MiB.
  • Follows the requirements of Bidding function interface.
  • Must support execution without any inputs during the initialization in the sandbox.

Example:

{
  "name": "bidders/1234567678/biddingFunctions/my_bidding_function_name",
  "biddingFunction": "(function(inputs) {
    ...
    return {
        'buyerCreativeId': 'ad_creative_id_1',
        'bidPriceCpm': 0.3,
        'productIds': ['product_id_1', 'product_id_2', 'product_id_3'],
        'debugString': 'Bidding function executed successfully!'
      }
    }
  )"
  "type": "FLEDGE_BIDDING_FUNCTION"
}

Create bidding function

A bidding function will be available for use in interest group responses within about an hour after a successful CreateBiddingFunction API call.

POST https://realtimebidding.googleapis.com/v1alpha/{parent=bidders/*}/biddingFunctions

Path parameters

parent String in the format bidders/{bidderAccountId}

Body of bidding function

{
  "name": "bidders/1234567678/biddingFunctions/my_bidding_function_name",
  "biddingFunction": "(function(inputs) {
    ...
    return {
        'buyerCreativeId': 'ad_creative_id_1',
        'bidPriceCpm': 0.3,
        'productIds': ['product_id_1', 'product_id_2', 'product_id_3'],
        'debugString': 'Bidding function executed successfully!'
      }
    }
  )"
  "type": "FLEDGE_BIDDING_FUNCTION"
}

Response (bidding function)

{
  "name": "bidders/1234567678/biddingFunctions/my_bidding_function_name",
  "biddingFunction": "(function(inputs) {
    ...
    return {
        'buyerCreativeId': 'ad_creative_id_1',
        'bidPriceCpm': 0.3,
        'productIds': ['product_id_1', 'product_id_2', 'product_id_3'],
        'debugString': 'Bidding function executed successfully!'
      }
    }
  )"
  "type": "FLEDGE_BIDDING_FUNCTION"
}

List existing bidding functions

GET https://realtimebidding.googleapis.com/v1alpha/bidders/{bidderAccountId}/biddingFunctions

Path parameters

parent String in the format bidders/{bidderAccountId}

Query parameters

pageToken String token identifying a page of results the server should return. This value is received from a previous ListBiddingFunctions call response, if the results do not fit on one page.

Response

{
  "biddingFunctions": [
    {
      object (BiddingFunction)
    }
  ],
  "nextPageToken": string
}

Call example:

GET https://realtimebidding.googleapis.com/v1alpha/bidders/123456789/biddingFunctions

FLEDGE simulation RTB protocol changes

Authorized Buyers RTB protocol

Bid requests

A contextual bid request in the experiment will look the same as the conventional bid requests but with pseudonymous user identifiers redacted.

// All fields will be filled unless otherwise specified.
message BidRequest {
  // Fields below would not be populated in the experiment
  optional string google_user_id = …;
  optional uint32 cookie_version = …;
  optional int32 cookie_age_seconds = …;
  optional bytes hosted_match_data = …;
  optional string session_id = …;

  // Contextual fields below will be populated
  optional string publisher_id = …;
  optional string url = …;
  …
  message Mobile {
    // Device advertising identifiers below would not be populated
    // in the contextual requests in the experiment
    optional bytes encrypted_advertising_id = …;
    optional bytes advertising_id = …;
    …
    optional bytes encrypted_hashed_idfa = …;
    optional bytes hashed_idfa = …;
    …
  }
  …
  message AdSlot {
    message MatchingAdData {
      repeated int64 billing_id = …;
      …
    }
    …
  }
  repeated AdSlot adslot = …;
  …
}

An interest-based request in the experiment will contain conventional pseudonymous user identifiers, subject to all the existing privacy protections and controls, but would not contain the contextual information (page URL, publisher ID, etc.).

// Most fields would not be populated in the experiment unless otherwise specified.
message BidRequest {
   // Will be provided, subject to the existing privacy controls.
  optional string google_user_id = …;
  optional uint32 cookie_version = …;
  optional int32 cookie_age_seconds = …;
  optional bytes hosted_match_data = …;

  message AdSlot {
    // Will be filled.
    repeated int32 width = ...;
    repeated int32 height = ...;
    optional ConsentedProvidersSettings consented_providers_settings = ...;
    optional bool regs_gdpr = ...;
    optional bool regs_lgpd = ...;

    message MatchingAdData {
      // Will be filled.
      repeated int64 billing_id = …;
      …
    }
    …
  }
  repeated AdSlot adslot = …;
  …
}

Example:

id: "_\322\207\000\003\320\n\031\177C\307\215\035"
adslot {
  id: 1
  width: 1200
  height: 60
  consented_providers_settings {
    consented_providers: 292
    tcf_consent_string: "CO-eDrRO-eDrREkAAAENAwCAAAAAkeYwf95y3p-wzhheMs-8NyZeH_B4Wv2MyvHT3ZCY70-vv__7v3ff_3g" }
  regs_gdpr: true
  matching_ad_data {
    billing_id: 1234567890
  }
}
google_user_id: "BFEUKH3"
hosted_match_data: "FEI3F3I29"

Bid responses

A contextual bid response will be needed to participate in the simulated FLEDGE-style bidding for the given ad request. It is not required to return a contextual bid, but returning information regarding the participation in the simulated interest group bidding will be required. The response will need to have at least the interest_group_buyers map filled with the interest group buyer information keyed by the buyer's domain name, which will then need to match the buyer_domain_name in the interest-based bid response. An optional bidder-specific per_buyer_signals can be specified in the bid response, which will then be provided as an argument to the bidding function.

message BidResponse {
  message Ad {
    message AdSlot {
      required int64 max_cpm_micros = …;
      ...
    }
    repeated AdSlot adslot = …;
    ...
  }
  repeated Ad ad = …;

  ...

  // Information used for running interest group auctions in a separate
  // execution environment, such as the TURTLEDOVE in-browser or simulated
  // server-side flow. In the FLEDGE simulation, this should be populated in the
  // contextual bid response.
  message InterestGroupBidding {
    // Information regarding an interest group buyer for the in-browser auction.
    message InterestGroupBuyer {
      // Optional buyer-specific inputs to the bidding function. Currently, only
      // applicable to and used in the FLEDGE simulation, where it is passed to
      // the bidding function as an argument.
      //
      // An object in a bidder-defined format that will be transformed into a
      // JSON object following Proto3 JSON representation
      // (https://developers.google.com/protocol-buffers/docs/proto3#json).
      // Can be left empty if no additional signals are
      // required by the bidding function.
      optional .google.protobuf.Value per_buyer_signals = …;
    }

    // Map of one or more interest group owners that the bidder would enter
    // into the interest group auction, keyed by the buyer's domain name.
    // Interest groups from a buyer without a corresponding entry here will 
    // not participate in the auction.
    map<string, InterestGroupBuyer> interest_group_buyers = …;
  }
  optional InterestGroupBidding interest_group_bidding = …;
  ...
}

Example:

ad {
  html_snippet: "<iframe src=\"http://example.com/something" width=\"300\" height=\"250\" ></iframe>"
  adslot {
    id: 1
    max_cpm_micros: 100000
    billing_id: 1234567890
  }
  click_through_url: "https://www.example-dsp.com"
  attribute: 47
  buyer_creative_id: "FFI399F3HI9HFH"
  width: 300
  height: 250
  impression_tracking_url: "http://example-dsp.com/impression"
}

interest_group_bidding {
  interest_group_buyers {
    map_field {
     key: "example-dsp.com"
     value {
       per_buyer_signals {
         struct_value {
           fields {
             name: "per_buyer_string_data_name"
             value {
               string_value: "string_value_3"
             }
           }
         }
       }
     }
  }
}
processing_time_ms: 1

An interest group-based bid

A response to the simulated interest-based bid request will contain one or more requests to execute a bidding function, each with a reference to the function by its name. Each such request to execute a bidding function can be made for a logical group of one or more related ads provided in the bid response, for instance, different variants of a creative relevant for the same interest group hosted by a bidder. Bidding functions will be provided by a bidder ahead of time. The buyer domain name specified on the interest group should match one of the buyer domain names specified on the contextual bid response.

// All fields should be filled by a bidder as discussed in
// d.g.c./authorized-buyers/rtb/response-guide
// unless otherwise specified.
message BidResponse {
  message Ad {
    // Ad HTML code that will be rendered normally upon winning.
    optional string html_snippet = …;

    message AdSlot {
      // Should not be populated for simulated interest group-based bids.
      required int64 max_cpm_micros = …;
      ...
      // Reference to the simulated FLEDGE interest group this ad belongs to;
      // must be one of the map keys in BidResponse.interest_group_map.
      optional string interest_group_name = …;

      // Bidder-provided inputs to the bidding function (ad-level information).
      // Only applicable to and used in the FLEDGE simulation, where it is
      // passed to the bidding function as an argument.
      //
      // An object in a bidder-defined format. When passed to the bidding
      // function, it will be converted to a JSON object using the proto3
      // canonical JSON representation
      // (https://developers.google.com/protocol-buffers/docs/proto3#json).
      // This field simulates 'ads' data in FLEDGE.
      // https://github.com/WICG/turtledove/blob/main/FLEDGE.md#11-joining-interest-groups
      optional .google.protobuf.Value ad_data = …;

    }
    repeated AdSlot adslot = …;

  }
  repeated Ad ad = …;

  message InterestGroup {
    // Expected to be specified by the bidder.
    // References a bidding function that is provided by the bidder ahead of
    // time via Bidding functions API resource. See
    // https://developers.google.com/authorized-buyers/apis/realtimebidding/reference/rest/v1alpha/bidders.biddingFunctions
    optional string bidding_function_name = …;

    // Inputs to the bidding function specified by the bidder. Only applicable
    // to and used in the FLEDGE simulation, where it is passed to the bidding
    // function as an argument.
    //
    // An object in a bidder-defined format. When passed to the bidding
    // function, it will be converted to a JSON object using the proto3
    // canonical JSON representation
    // (https://developers.google.com/protocol-buffers/docs/proto3#json).
    optional .google.protobuf.Struct user_bidding_signals = …;

    // Inputs to the bidding function specified by the bidder. Only applicable
    // to and used in the FLEDGE simulation, where it is passed to the bidding
    // function as an argument.
    // Can help simulate the results of fetching trusted bidding signals in
    // FLEDGE proposal
    // (https://github.com/WICG/turtledove/blob/main/FLEDGE.md#31-fetching-real-time-data-from-a-trusted-server).
    //
    // An object in a bidder-defined format. When passed to the bidding
    // function, it will be converted to a JSON object using the proto3
    // canonical JSON representation
    // (https://developers.google.com/protocol-buffers/docs/proto3#json).
    optional .google.protobuf.Struct trusted_bidding_signals = 3;

    // Interest group owner's domain name to associate the per_buyer_signals
    // (from the contextual bid response) to their corresponding
    // invocations of the bidding functions in the FLEDGE simulation. This value
    // must match the interest group buyer domain name configured for the
    // bidder's account.
    optional string buyer_domain_name = …;
  }

  // Bidder-provided inputs that are used bidding functions in order to compute
  // bids and choose ads in the FLEDGE simulation.
  map<string, InterestGroup> interest_group_map = …;
  ...
}

Example:

ad {
  html_snippet: "<iframe src=\"http://example.com/something" width=\"300\" height=\"250\" ></iframe>"
  adslot {
    id: 1
    max_cpm_micros: 0
    billing_id: 1234567890
    interest_group_name: "interest-group-name-1"
    ad_data {
      struct_value {
        fields {
          name: "string_data_name"
          value {
            string_value: "string_value_1"
          }
        }
        fields {
          name: "bool_data_name"
          value {
            bool_value: true
          }
        }
      }
    }
  }
  click_through_url: "https://www.example-dsp.com.pl"
  attribute: 47
  buyer_creative_id: "FFI399F3HI9HFH"
  width: 300
  height: 250
  impression_tracking_url: "http://example-dsp.com/impression"
}
interest_group_map {
  map_field {
   key: "interest-group-name-1"
   value {
     bidding_function_name: "bidders/123/biddingFunctions/my_bidding_function_1"
     user_bidding_signals {
       fields {
         name: "bidding_signal_string_data_name"
         value {
           string_value: "string_value_1"
         }
       }
       fields {
         name: "bidding_signal_bool_data_name"
         value {
           bool_value: true
         }
       }
     }
     trusted_bidding_signals {
       fields {
         name: "trusted_string_data_name"
         value {
           string_value: "string_value_2"
         }
       }
     }
     buyer_domain_name: "example-dsp.com"
   }
  }
}

processing_time_ms: 1

OpenRTB

Bid requests

Contextual request (in JSON)
// All fields will be filled unless otherwise specified.
{
  // Fields below would not be populated in the experiment
  "user": {...}

  "device": {
    // Fields below would not be populated in the experiment
    "ifa": ...
    "dpidsha1": ...
    "dpidmd5": ...


    // Other fields will not be affected by the experiment
    ...
  }

  // Other fields will not be affected by the experiment
  ...
}
Interest-based request (in JSON)
// Most fields would not be populated in the experiment unless otherwise specified.
{
  // Will be provided, subject to the existing privacy controls.
  "user": {
    "id": "BFEUKH3"
    "buyeruid": "FEI3F3I29"
    "ext": {
      "consented_providers": [292]
      "tcf_consent_string": "CO-eDrRO-eDrRAA.IGLtV_T9f_tkeYwy3p-wheMs-8NyZeH_B4WT3ZCY70-vv__7v3ff_3g"
    }
  }

  "imp": {
    // Will be provided
    "banner": {
      "w": ...
      "h": ...
    }

    "ext": {
      // Will be provided
      "billing_id": [...]

      // Other fields will not be provided by the experiment
      ...
    }
  }
}

Bid responses

// All fields should be filled by a bidder as discussed in
// d.g.c./authorized-buyers/rtb/response-guide
// unless otherwise specified.
{
  "bid": [{
       "id": ...
    }
    ...
  ]
  "ext": {
    // Contextual information required for running interest group auctions in a
    // separate execution environment, such as the TURTLEDOVE in-browser or
    // simulated server-side flow. In the TURTLEDOVE simulation, this should be
    // populated in the contextual bid response.
    "interest_group_bidding": {
      // Information regarding an interest group buyer for the in-browser
      // auction. auction.
      "interest_group_buyers": {
        "example.com": {
          // Optional buyer-specific inputs to the bidding function. Currently, only
          // applicable to and used in the FLEDGE simulation, where it is passed to
          // the bidding function as an argument.
          //
          // An object in a bidder-defined format that will be transformed into a
          // JSON object following Proto3 JSON representation
          // (https://developers.google.com/protocol-buffers/docs/proto3#json).
          // Can be left empty if no additional signals are
          // required by the bidding function.
          "per_buyer_signals": {
            "per_buyer_string_data_name": "string_value_3"
          }
        }
      }
    }
  }
}
An interest group-based bid response
// All fields should be filled by a bidder as discussed in
// d.g.c./authorized-buyers/rtb/response-guide
// unless otherwise specified.
{
  "bid": [{
       "id": ...
       ...
       "ext": {
          // Reference to the simulated FLEDGE interest group for this ad;
          // must be one of the map keys in BidResponse.interest_group_map.
          "interest_group_name": "interest-group-name-1"

          // Bidder-provided inputs to the bidding function (ad-level information).
          // Only applicable to and used in the FLEDGE simulation, where it is
          // passed to the bidding function as an argument.
          //
          // An object in a bidder-defined format. When passed to the bidding
          // function, it will be converted to a JSON object using the proto3
          // canonical JSON representation
          // (https://developers.google.com/protocol-buffers/docs/proto3#json).
          // This field simulates 'ads' data in FLEDGE.
          // https://github.com/WICG/turtledove/blob/main/FLEDGE.md#11-joining-interest-groups
          "ad_data": {
            "string_data_name": "string_value_1",
            "bool_data_name": true
          }
       }
    }
    ...
  ]
  "ext": {
    // Bidder-provided inputs that a bidder requests to execute their bidding
    // functions for in order to compute bids and choose ads in the FLEDGE
    // simulation.
    "interest_group_map": {
      // A request by a bidder to execute a given bidding function in the FLEDGE
      // simulation in order to compute a bid and choose an ad. This also includes
      // inputs that will be provided to the bidding function.
      // https://github.com/WICG/turtledove/blob/main/FLEDGE.md#11-joining-interest-groups
      "interest-group-name-1": {
        // References a bidding function that is provided by the bidder ahead of
        // time via Bidding functions API resource. See
        // https://developers.google.com/authorized-buyers/apis/realtimebidding/reference/rest/v1alpha/bidders.biddingFunctions
        "bidding_function_name": "bidders/123/biddingFunctions/my_bidding_function_1",

        // Inputs to the bidding function specified by the bidder. Only applicable
        // to and used in the FLEDGE simulation, where it is passed to the bidding
        // function as an argument.
        //
        // An object in a bidder-defined format. When passed to the bidding
        // function, it will be converted to a JSON object using the proto3
        // canonical JSON representation
        // (https://developers.google.com/protocol-buffers/docs/proto3#json).
        "user_bidding_signals": {
          "bidding_signal_string_data_name": "string_value_1"
          "bidding_signal_bool_data_name": true
        },

        // Inputs to the bidding function specified by the bidder. Only applicable
        // to and used in the FLEDGE simulation, where it is passed to the bidding
        // function as an argument.
        // Can help simulate the results of fetching trusted bidding signals in
        // FLEDGE proposal
        // (https://github.com/WICG/turtledove/blob/main/FLEDGE.md#31-fetching-real-time-data-from-a-trusted-server).
        //
        // An object in a bidder-defined format. When passed to the bidding
        // function, it will be converted to a JSON object using the proto3
        // canonical JSON representation
        // (https://developers.google.com/protocol-buffers/docs/proto3#json).
        "trusted_bidding_signals": {
          "trusted_string_data_name": "string_value_2"
        },

        // Interest group owner's domain name to associate the contextual
        // per_buyer_signals from the bid response to their corresponding
        // invocations of the bidding functions in the FLEDGE simulation. This value
        // must match the interest group buyer domain name configured for the
        // bidder's account.
        "buyer_domain_name": "example-dsp.com"
      }
    }
  }
}