Proposal: previous auction info module

[bretg]

Over the years, the Prebid Server team has gotten requests to support "loss notifications" so bidders can refine their bidding algorithms. Whenever the request comes up, we decline with 3 objections:

• Prebid Server does not define the winner or loser of an auction and is not in the notification path. The ad server could choose a non-Prebid bid to win, there could be bid caching, there could be client-side price adjustments, etc. Bottom line is that Prebid cannot commit to knowing the "min bid to win".
• Hosting Prebid Server is expensive already - we do not want to support a 'real-time' notification because that adds to outbound network traffic.
• Putting some kind of info in a subsequent auction request would be ok, but the IAB has not seen fit to define a location to put it, and Prebid does not want to be in the business of defining OpenRTB extensions used as important conventions by other parties.

But the issue comes up again periodically, so in the spirit of trying to move the conversation forward, here's an option for Prebid Server to offer a relatively inexpensive way to provide the info that is available. Bidders need to be willing to (A) read from a Prebid extension, (B) accept incomplete info (C) be ready to join data on their side, and (D) be flexible about the timing of getting the data.

There are absolutely no guarantees about receiving "min bid to win" info at all. PBS will take reasonable efforts to piggy-back previous auction info on a future auction. It may come significantly delayed or might not come at all. Bidders will need to decide on their lookback period for joining into their data set.

1. Define a way for bidders to opt-in. This feature creates compute burden, so bidders not ready to use it should not add to that burden.

It's ok if this is a module config that has to be updated for each bidder on each host company. Perhaps ask bidders that support this feature to update their Prebid docs with a flag.

2. Define a prebid-specific "previous auction info" object on outgoing bid requests for which the bidder had actually successfully bid above the floor. The idea is that we need to avoid sending info to bidders are weren't serious about actually bidding. If there was a failure, that signal would be ok, but they can't get the actual highest bid without a successful bid.

Case of a successful bid:

$.ext.prebid.previousauctioninfo: [{
          source: "pbs",
          bidderRequestId: "123abc",               // never specified by PBS - no such thing
          auctionId: STRING,                              // $.id of the previous auction
          impId: STRING,                                    // $.imp.id of the previous auction
          bidId: "456def",                                   //  seatbid[].bid[].id of the previous auction
          rendered: 1, // default is 0                   // never specified by PBS, will be forwarded from PBJS if present
          adUnitCode: "div-gpt-ad-123-0",      // imp.ext.gpid or imp.id
          highestBidCpm: 0.052275935,          // the highest bid for the imp this bid was a part of in the auction currency.
          highestBidCurrency: "USD",               // the auction currency
          bidderCpm: 0.04, // default is null.     // this bidder's bid in the auction currency
          bidderOriginalCpm: 0.04,                    // this bidder's original bid
          bidderOriginalCurrency: "USD",         // this bidder's original bid currency
          rejectionReason: -1,                            // not specified by PBS for successful bids
          timestamp: 1739400860310
}]

Case of a rejected bid:

$.ext.prebid.previousauctioninfo: [{
          source: "pbs",
          bidderRequestId: "123abc",               // never specified by PBS - no such thing
          auctionId: STRING,                              // $.id of the previous auction
          impId: STRING,                                    // $.imp.id of the previous auction
          bidId: "456def",                                   //  seatbid[].bid[].id of the previous auction
          adUnitCode: "div-gpt-ad-123-0",      // imp.ext.gpid or imp.id
          rejectionReason: SEATNONBID,        // only successful bids will ever get highestBidCpm
          timestamp: 1739400860310
}]

If Prebid.js sent previous auction info on the request for this bidder, append it to anything produced by PBS.

{
  ext.prebid.bidderconfig:
    bidders: ["bidderA"],
    config: {
      ortb2: {
        ext.prebid.previousauctioninfo: [{...}, {...}]
      }
    }
}

Note: this is going to require an update to bidderconfig because currently it only supports site/app/user, and soon to be device.

3. Create a module that caches auction results and forwards them on the next auction

Runs at 2 stages:

• All Processed Bid Response Stage: if a bidder provides one or more bids, append them to a data structure:

However this is efficiently implemented in the code, logically, it's just a queue for each bidder:

{
   "bidderA": [{                            // supply highestBidCpm only if the bid was not rejected
          auctionId: STRING,                              // $.id of the previous auction
          impId: STRING,                                    // $.imp.id of the previous auction
          bidId: "456def",                                   //  seatbid[].bid[].id of the previous auction
          adUnitCode: "div-gpt-ad-123-0",      // imp.ext.gpid or imp.id
          highestBidCpm: 0.052275935,          // the highest bid for the imp this bid was a part of in the auction currency.
          highestBidCurrency: "USD",               // the auction currency
          bidderCpm: 0.04,                                 // this bidder's bid in the auction currency
          bidderOriginalCpm: 0.04,                    // this bidder's original bid
          bidderOriginalCurrency: "USD",         // this bidder's original bid currency
          timestamp: 1739400860310
   },{
          auctionId: STRING,                              // $.id of the previous auction
          impId: STRING,                                    // $.imp.id of the previous auction
          bidId: "456def",                                   //  seatbid[].bid[].id of the previous auction
          adUnitCode: "div-gpt-ad-123-0",      // imp.ext.gpid or imp.id
          bidderCpm: 0.04,                                 // this bidder's bid in the auction currency
          bidderOriginalCpm: 0.04,                    // this bidder's original bid
          bidderOriginalCurrency: "USD",         // this bidder's original bid currency
          rejectionReason: 301,                         // did not meet floor
          timestamp: 1739400860310
   }],
   "bidderB" : [{
      ...
    }]
}

NoBids (seatnonbid code 0) are not added to the data structure.

• Bidder Request Stage: when a request is about to go out to a bidder, pull all previous auction info blocks off the bidder's queue and add them to the ORTB request.

That's it. Configuration of the module would define which bidders to do this for and max queue length.

To minimize mutex contention, I would propose very loose timing requirements. It would be ok for every thread to have it's own copy of the bidresponse queue, or for there to be a configurable number of queues per server that are processed round-robin. The implication is that there's absolutely no guaranteed about if/when the bidder would receive the additional information. e.g:

• if there are 1000 threads in a large server and traffic is declining, the previous auction info in thread 999 might get stuck there until traffic rises the next day.
• if the server is restarted, any cached info is lost with no attempt to save or transmit

3. Make sure there's a configurable max size. Optionally there could also be a max amount of time that the previous auction info can stay on the queue.

---

Discuss.

[bretg]

Discussed in committee. This is still of some interest, but not a high priority. This addresses only a "min bid to win" use case, not a "pacing improvement" use case.

[bretg]

Discussed in committee: keeping this on hold until there's enough interest to push it further.

[bretg]

There's a Prebid.js pull request open around this general topic -- prebid/Prebid.js#11086. So apparently there's some interest out there. I believe from pubmatic. The pull request isn't aligned with the proposal here.

[bretg]

Update: there's been work on on this done for Prebid.js in prebid/Prebid.js#11086

I've requested that the community take this up and debate the details.

              bidderRequestId: bidderRequest.bidderRequestId,          // not sure what this ID is.
              minBidToWin: highestCpmBid?.cpm || 0,                            // replaces highestcpm?
              rendered: 0,                                                                           // new
              transactionId: bid.ortb2Imp.ext.tid || bid.transactionId,    // only when transmitTid allowed
              source: 'pbjs',
              auctionId: auctionDetails.auctionId,                                   // only when transmitTid allowed
              impId: bid.adUnitCode,
              bidResponseId: FLOAT, // don't think this is available client side?
              targetedbidcpm: FLOAT, // don't think this is available client side?
              highestcpm: highestCpmBid?.cpm || 0,
              cur: bid.ortb2.cur,
              bidderCpm: receivedBidsMap[bid.bidId] ? receivedBidsMap[bid.bidId].cpm : 'nobid',
              biddererrorcode: rejectedBidsMap[bid.bidId] ? rejectedBidsMap[bid.bidId].rejectionReason : -1,
              timestamp: auctionDetails.timestamp,

[Slind14]

Thought a bit more about this. Given that PBS has less knowledge than PBJS, couldn't this just be an optional pass through for PBS. Meaning all the logic sits on the PBJS side which is also where the publisher has control and visibility into what is shared.

Or is this specifically about non PBJS integrations of PBS?

[bretg]

The PBJS module was tweaked in prebid/Prebid.js#12988 updated the original description to reflect the update.

Given that PBS has less knowledge than PBJS, couldn't this just be an optional pass through for PBS

Good point @Slind14 . This issue already describes that core should be updated to support bidder-specific config for ext.prebid.previousauctioninfo. "If Prebid.js sent previous auction info on the request for this bidder, append it to anything produced by PBS."

So while that may lower the urgency, I would guess that mobile app, audio, dooh, and CTV bidders will also ask for this functionality someday.

[bretg]

If we assume that clients will keep state (e.g. enhance PB SDK like PBJS), then the job of PBS becomes simpler: just let the client know which bidders want the state. That could be a seatbid.bid.ext.prebid.relaypreviousauctioninfo:true flag that indicates to the client that they should keep state and forward the results of this auction on the next auction.

In this scenario, the client needs to be careful about not returning previousauctioninfo for auctions that haven't been decided yet: i.e. the ad server/mediation layer hasn't rendered anything for that adunit.

It's noted that "previous" auction doesn't necessarily mean Auction-1 ... the info could be for several auctions ago. Maybe hundreds of auctions. No guarantees.

Prebid Server bidder config (e.g. YAML, new option to "requestPreviousAuctionInfo: true"). This option causes PBS-core to add seatbid.bid.ext.prebid.relaypreviousauctioninfo:true to every successful bid. PBS-core should strip seatbid.bid.ext.prebid.relaypreviousauctioninfo if it was provided by the bidder.

Here's what a client (SDK, PBJS) would need to do:

1. If the PBS bid contains seatbid.bid.ext.prebid.relaypreviousauctioninfo:true, then it's being asked to keep state for this bid.
2. Client stores state about whether the auction is "closed" -- meaning that adunit has been rendered, whether by Prebid or something else. There are scenarios where Prebid bids might be pre-loaded and then never sent to an ad server.
3. Before kicking off the next call to PBS, the client reads the bid cache and attaches all bids for "closed" auctions as previousauctioninfo. Then remove the state for all of these closed auctions that were sent on the previousauctioninfo.
4. The client can remove any unclosed auctions after the session, or X hours.

This doesn't cover the communication of the NONBID scenarios back to bidders. That can be covered in a future enhancement.

[bretg]

Discussed internal to Magnite. We're good with this except that the rendered flag isn't needed because the bidder will know from the log join if we rendered. So the client (PBJS/SDK) doesn't necessarily need to wait for the auction to close because the bidder will know about render offline. Waiting for the ad server doesn't give us a better sense of the winning CPM, so no need to wait.

From a PBS perspective though, this doesn't matter much. I propose moving ahead with this server-side plan:

1. Bidder YAML config adds an optional "requestPreviousAuctionInfo: true" flag.
2. If this flag is present, PBS-core to add seatbid.bid.ext.prebid.relaypreviousauctioninfo:true to every successful bid
3. PBS-core strips seatbid.bid.ext.prebid.relaypreviousauctioninfo if it was provided by the bidder.
4. PBS-core is expanded to support merging ext.prebid.bidderconfig.config.ortb2.ext.prebid.previousauctioninfo (currently that merge only supports user/site/app/device)

The proposed client updates:

1. The new PBJS module accepts seatbid.bid.ext.prebid.relaypreviousauctioninfo:true from Prebid Server, keeping state for that bidder as requested.
2. The new PBJS module adds the bidderconfig for previous auctioninfo.
3. The prebidServerBidAdapter forwards that bidderconfig to PBS.

^^ @jlquaccia

[Net-burst]

Discussed in the Prebid Server committee. We'll raise the issue with PBJS and PBSDK committees for possible concerns on their end about the proposed implementation and if there is none, we can mark the server side of the support as ready for dev.