Super Auction

What is Super Auction?

Super Auction is Verizon Media’s in-app header bidding solution for mobile app publishers. With Super Auction, an app’s ad inventory can be exposed to multiple demand sources all at once in real-time, leading to more competition for every impression and better yield.

How does Super Auction work?

After integrating the Verizon Ads SDK and creating Super Auction-specific placements in the SSP, you will use the placement’s requestBid API to hold a Super Auction. When requestBid is called, the SSP will ask Super Auction-enabled demand sources for bids and return the highest-priced bid (and the ad associated with that bid) to the Verizon Ads SDK.

This bid price can be used in a number of ways. It can be evaluated in real time within the app against other bid providers, or it can be transmitted to another SSP or ad server to compete server-side with direct-sold campaigns, networks, and other programmatic demand. If the bid provided by the Verizon Ads SDK is deemed the winner, displaying the ad will deliver the impression and generate revenue.

Integration and Setup

1. Add the Verizon Ads SDK to the project

See the Integration Guide for a complete walkthrough.

2. Set up Super Auction placements in the SSP

Using Super Auction requires specially-configured placements in the SSP. A Verizon Media representative can walk you or your team through the entire process.

3. Integrate the Super Auction API

Super Auction’s point of integration is the requestBid API. This section will advise how to use the API for inline and interstitial placements.

Inline Placements

Call the requestBid API as shown in the example below. Note that a Super Auction placement ID and the ad size are required parameters to send in the call.

These code examples demonstrate the flow for Super Auction for inline placements.

Make the bid request
// example dimensions
int width = 320, height = 50;
adSize = new AdSize(width, height);
List<AdSize> adSizes = new ArrayList<>();
adSizes.add(adSize);
// Optionally use request metadata builder here to add targeting data

InlineAdFactory.requestBid(this, myPlacementId, adSizes, null, this);

@Override
public void onComplete(Bid bid, ErrorInfo errorInfo) {

    if (errorInfo != null) {
        // Error handling here
    } else {
        // Bid object returned for evaluation
        this.bid = bid;
    }
 }
[VASInlineAdFactory requestBidForPlacementId:myPlacementId
                                     adSizes:@[self.size]
                             requestMetadata:nil
                                      vasAds:[VASAds sharedInstance]
                                  completion:^(VASBid * _Nullable bid, VASErrorInfo * _Nullable error) {
                                      if (error) {
                                          // Error handling here
                                      } else {
                                          self.bid = bid
                                      }
                                  }];
VASInlineAdFactory.requestBid(
            forPlacementId: myPlacementId,
            adSizes: [VASInlineAdSize(width: 320, height: 50)],
            requestMetadata: nil,
            vasAds: VASAds.sharedInstance,
            completion: { (bid, error) -> Void in
                if bid != nil {
                    self.bid = bid
                } else {
                    // Error handling here
                }
        })
Load the bid
InlineAdFactory inlineAdFactory = new InlineAdFactory(this, myPlacementId, adSizes, this);
inlineAdFactory.load(bid, this);

// clear out bid once it's used
bid = null;
if (self.bid) {
    [self.adFactory loadBid:self.bid inlineAdDelegate:self];
    self.bid = nil;
}
let size: VASInlineAdSize = VASInlineAdSize(width: 320, height: 50)
var inlineAdFactory = VASInlineAdFactory(placementId: myPlacementId, adSizes: [size], vasAds: VASAds.sharedInstance, delegate: self)
if let bid = self.bid {
    inlineAdFactory.load(bid, inlineAdDelegate: self)
}
// clear out bid once it's used
self.bid = nil

Interstitial Placements

These code examples demonstrate the flow for Super Auction for interstitial placements.

Make the bid request
InterstitialAdFactory.requestBid(myActivity, myPlacementId, null, new BidRequestListener() {

@Override
public void onComplete(Bid bid, ErrorInfo errorInfo) {

    if (errorInfo != null) {
        // Error handling here
    } else {
        // Bid object returned for evaluation
        this.bid = bid;
    }
 }
[VASInterstitialAdFactory requestBidForPlacementId:myPlacementId
                                   requestMetadata:nil
                                            vasAds:[VASAds sharedInstance]
                                        completion:^(VASBid * _Nullable bid, VASErrorInfo * _Nullable error) {
                                            if (error) {
                                                // Error handling here
                                            } else {
                                                self.bid = bid
                                            }
                                        }];
VASInterstitialAdFactory.requestBid(
            forPlacementId: myPlacementId,
            requestMetadata: nil,
            vasAds: VASAds.sharedInstance,
            completion: { (bid, error) -> Void in
                if bid != nil {
                    self.bid = bid
                } else {
                    // Error handling here
                }
        })
Load the bid
InterstitialAdFactory interstitialAdFactory = new InterstitialAdFactory(this, myPlacementId, this);
interstitialAdFactory.load(bid, this);

// clear out bid once it's used
bid = null;
if (self.bid) {
    [self.interstitialAdFactory loadBid:self.bid interstitialAdDelegate:self];
    self.bid = nil;
}
var interstitialAdAdFactory = VASInterstitialAdAdFactory(placementId: myPlacementId, vasAds: VASAds.sharedInstance, delegate: self)
if let bid = self.bid {
    interstitialAdAdFactory.load(bid, interstitialAdDelegate: self)
}
// clear out bid once it's used
self.bid = nil