Dynamic bid floors in MAX

Since the transition to real time bidding, ad monetisation managers have lost control and visibility in their waterfalls. Setting floor prices is the mechanism to optimise bidding networks and deliver ad revenue uplift to partners. Nefta has seen 10-20% ad revenue increase with a comprehensive use of bid floor prices. In order to effectively set floor prices, partners need advanced user value estimation models and market price or bid landscape models.

Setup in MAX

Partners should set up multiple Ad Units per Ad Format in the MAX dashboard. It's suggested to have one default ad unit per ad format and numerous additional ad units with a floor price set. The floor price will be set at different bucket intervals, for example: 1, 5, 10, 20, 50, 100, 500.

The right number of ad units

In general the more ad units with a floor price bucket per ad format, the better. If you have a limit of ad units per ad format, its suggested to talk to your Applovin account representative to increase. If this is not possible, start with as many as possible and optimise from there. Discuss with your Nefta account representative.

Setting the right floor prices

To get started, its suggested to use a best guess approach of value buckets for your users. Alternatively, discuss with your Nefta account representative to provide value buckets based on the ad data available.

Optimising floor buckets

Using data to understand which floor price buckets are delivering the largest fill rate and splitting the floor bucket into new price buckets.
Analysing predicted user value in the default ad unit to discover additional untapped value buckets to add.

Receive the dynamic bid floor for the user from Nefta

Firstly, integrate user insights and request the following user insight values:

Predicted floor price per user per ad format: calculated_user_floor_price_banner, calculated_user_floor_price_interstitial, calculated_user_floor_price_rewarded.

Select the right initial Ad Unit

Using the calculated_user_floor_price_* value as requested above, select the Ad unit with the closest bid floor price and call the function MaxSdk.LoadRewardedAd(adUnitId); in the case of a rewarded ad unit.

Ad unit selection logic:

Partners can select the closest ad unit with a floor price from calculated_user_floor_price_*, this will result in a higher chance of fill but less optimisation.
Partners can select the closest ad unit with a percentage difference, for example above/bellow 5%.

It's important to continuously optimise the ad unit selection, number of ad units and price buckets.

Initial Ad Unit has no fill

If the initially selected ad unit doesn't return an ad:

Re-request the bid floor price, the new floor price takes into account the previous no-fill event and is adjusted in real time. You can repeat this process for each ad opportunity. However, its suggested to have a max 2-shot or 3-shot system where the end request removes the floor price to ensure fill.

Example code

Below is example code (not production-ready) showing the potential integration of dynamic floors.

// Wrapper for Ads with bid floor selection logic  
class Ad : NSObject {
    
    private var _adType: ALNeftaMediationAdapterSwift.AdTypeSwift
    private var _adInsightName: String
    private var RequestNewInsights: () -> Void
    private let _adUnits: [String: Double]
    
    private var _insights: [String: Insight]?
    var _selectedAdUnitId: String?
    private var _calculatedBidFloor: Double = 0.0
    private var _consecutiveAdFail = 0
    private var _isLoadPending = false
  
    var InsightName: String {
        return ""
    }

    
    func SelectAdUnitFromInsights() {
        _selectedAdUnitId = _adUnits.first!.key
        
        if let insights = _insights {
            _calculatedBidFloor = insights[InsightName]?._float ?? 0

            for (adUnitId, cpm) in _adUnits {
                if cpm > _calculatedBidFloor {
                    break
                }
                _selectedAdUnitId = adUnitId
            }
            print("SelectAdUnitFromInsights for \(_adType): \(_selectedAdUnitId!)/cpm:\(_adUnits[_selectedAdUnitId!]!)), calculated bid floor: \(_calculatedBidFloor)")
        }
    }
    
    init(adType: ALNeftaMediationAdapterSwift.AdTypeSwift, adUnits: [String: Double], requestNewInsights: @escaping (() -> Void)) {
        _adType = adType
        _adUnits = adUnits
        RequestNewInsights = requestNewInsights
    }
    
    func Load() {
        if _selectedAdUnitId == nil {
            SelectAdUnitFromInsights()
        }
    }
    
    func OnUserInsights(insights: [String: Insight]) {
        _insights = insights
        
        SelectAdUnitFromInsights()
        
        if _isLoadPending {
            Load()
        }
    }
    
    func didFailToLoadAd(forAdUnitIdentifier adUnitIdentifier: String, withError error: MAError) {
        ALNeftaMediationAdapterSwift.OnExternalMediationRequestFail(_adType, requestedFloorPrice: _adUnits[_selectedAdUnitId!]!, calculatedFloorPrice: _calculatedBidFloor, adUnitIdentifier: adUnitIdentifier, error: error)
        
        if error.code == .noFill {
            _consecutiveAdFail += 1
            if _consecutiveAdFail > 2 {
                _selectedAdUnitId = _adUnits.first!.key
            } else {
                _isLoadPending = true
                RequestNewInsights()
            }
        }
    }
    
    func didLoad(_ ad: MAAd) {
        ALNeftaMediationAdapterSwift.OnExternalMediationRequestLoad(_adType, requestedFloorPrice: _adUnits[_selectedAdUnitId!]!, calculatedFloorPrice: _calculatedBidFloor, ad: ad)

        _consecutiveAdFail = 0
        // Optionally try to select adUnit with higher cpm again
        // SelectAdUnitFromInsights()
    }
}

// Example of Rewarded Ad
class Rewarded : AdHandler, MARewardedAdDelegate {
  
    public static let InsightName = "calculated_user_floor_price_banner"
    
    override var InsightName: String {
        get {
            return Banner.InsightName
        }
    }
  
    override func didFailToLoadAd(forAdUnitIdentifier adUnitIdentifier: String, withError error: MAError) {
        super.didFailToLoadAd(forAdUnitIdentifier: adUnitIdentifier, withError: error)
      
        SetInfo("didFailToLoadAd \(adUnitIdentifier): \(error)")
    }
    
    override func didLoad(_ ad: MAAd) {
        super.didLoad(ad)
        
        SetInfo("didLoad \(ad)")
    }
    
    @objc override func Load() {
        super.Load()
        
        _rewarded = MARewardedAd.shared(withAdUnitIdentifier: _selectedAdUnitId!)
        _rewarded.delegate = self
        _rewarded.load()
    }
  
 		// the rest of the implementation
}

// Main application entry point:
    let _bannerAdUnits = [
       "34686daf09e9b052": 25.0,
       "a843106cd98eb4d1": 50.0,
       "d066ee44f5d29f8b": 75.0,
   ]
    
    let _interstitialAdUnits = [
       "e5dc3548d4a0913f": 25.0,
       "2685d8127c299789": 50.0,
       "66e16b4b9b8d580a": 75.0,
   ]
    
    let _rewardedAdUnits = [
       "e0b0d20088d60ec5": 25.0,
       "d89c87aecdd15c7e": 50.0,
       "7267e7f4187b95b2": 75.0,
   ]
    
    override func viewDidLoad() {
        super.viewDidLoad()

        NeftaPlugin.EnableLogging(enable: true)
        _plugin = NeftaPlugin.Init(appId: "5661184053215234")
        
        _plugin.OnBehaviourInsight = OnBehaviourInsight
        GetBehaviourInsights()

        _banner = Banner(dUnits: _bannerAdUnits,
                         requestNewInsights: GetBehaviourInsights,
                         showButton: _showBanner, hideButton: _hideBanner, status: _bannerStatus, bannerPlaceholder: _bannerPlaceholder)
        _interstitial = Interstitial(adUnits: _interstitialAdUnits,
                                     requestNewInsights: GetBehaviourInsights,
                                     loadButton: _loadInterstitial, showButton: _showInterstitial, status: _interstitialStatus)
        _rewardedVideo = Rewarded(adUnits: _rewardedAdUnits,
                                  requestNewInsights: GetBehaviourInsights,
                                  loadButton: _loadRewarded, showButton: _showRewarded, status: _rewardedStatus)
        
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
            self.checkTrackingAndInitializeMax()
        }
    }
    
    private func GetBehaviourInsights() {
        _plugin.GetBehaviourInsight([Banner.InsightName, Interstitial.InsightName, Rewarded.InsightName])
    }
    
    private func OnBehaviourInsight(insights: [String: Insight]) {
        _banner.OnUserInsights(insights: insights)
        _interstitial.OnUserInsights(insights: insights)
        _rewardedVideo.OnUserInsights(insights: insights)
    }
    
		// the rest of your class
}

namespace AdDemo
{
    // Wrapper for Ads with bid floor selection logic    
    public abstract class AdHandler
    {
        private NeftaAdapterEvents.AdType _adType;
        private Action GetInsights;
        private List<AdConfig> _adUnits;
        
        private Dictionary<string, Insight> _insights;
        protected AdConfig _selectedAdUnit;
        private double _calculatedBidFloor;
        private int _consecutiveAdFail;
        private bool _isLoadPending;
      
        protected abstract string AdInsightName { get; }

        private void SelectAdUnitFromInsights()
        {
            _selectedAdUnit = _adUnits[0];
            
            if (_insights != null)
            {
                _calculatedBidFloor = _insights[AdInsightName]._float;

                foreach (var adUnit in _adUnits)
                {
                    if (adUnit._cpm > _calculatedBidFloor)
                    {
                        break;
                    }
                    _selectedAdUnit = adUnit;
                }
                Debug.Log($"SelectAdUnitFromInsights for {_adType}: {_selectedAdUnit.Id}/cpm:{_selectedAdUnit._cpm}, calculated bid floor: {_calculatedBidFloor}");
            }
        }

        protected Ad(NeftaAdapterEvents.AdType adType, List<AdConfig> adUnits, Action getInsights)
        {
            _adType = adType;
            _adUnits = adUnits;
            GetInsights = getInsights;
        }

        public virtual void Load()
        {
            if (_selectedAdUnit == null)
            {
                SelectAdUnitFromInsights();
            }
        }

        public void OnBehaviourInsight(Dictionary<string, Insight> insights)
        {
            _insights = insights;
            
            SelectAdUnitFromInsights();

            if (_isLoadPending)
            {
                Load();
            }
        }

        protected virtual void OnAdFailedEvent(string adUnitId, MaxSdkBase.ErrorInfo errorInfo)
        {
            NeftaAdapterEvents.OnExternalMediationRequestFailed(_adType, _selectedAdUnit._cpm, _calculatedBidFloor, adUnitId, errorInfo);
            
            if (errorInfo.Code == MaxSdkBase.ErrorCode.NoFill)
            {
                _consecutiveAdFail++;
                if (_consecutiveAdFail > 2)
                {
                    _selectedAdUnit = _adUnits[0];
                    Load();
                }
                else
                {
                    _isLoadPending = true;
                    GetInsights();
                }
            }
        }

        protected virtual void OnAdLoadedEvent(string adUnitId, MaxSdkBase.AdInfo adInfo)
        {
            NeftaAdapterEvents.OnExternalMediationRequestLoaded(_adType, _selectedAdUnit._cpm, _calculatedBidFloor, adInfo);
        }
    }

    // Example of Rewarded implementation
    public class Rewarded : AdHandler
    {
        public static string InsightName = "calculated_user_floor_price_rewarded";
      
        private readonly Action<string> _setStatus;
        private readonly Action _onLoad;

        private string _loadedAdUnitId;
      
        protected override string AdInsightName => InsightName;


        public Rewarded(List<AdConfig> adUnits, Action requestNewInsight, Action<string> setStatus, Action onLoad)
            : base(NeftaAdapterEvents.AdType.Interstitial, adUnits, requestNewInsight)
        {
            _setStatus = setStatus;
            _onLoad = onLoad;
            
            MaxSdkCallbacks.Rewarded.OnAdLoadedEvent += OnAdLoadedEvent;
            MaxSdkCallbacks.Rewarded.OnAdLoadFailedEvent += OnAdFailedEvent;
        }

        public override void Load()
        {
            base.Load();
            
            _loadedAdUnitId = _selectedAdUnit.Id;
            MaxSdk.LoadRewardedAd(_loadedAdUnitId);
        }
        
        public void Show()
        {
            if (MaxSdk.IsRewardedAdReady(_loadedAdUnitId))
            {
                _setStatus("Showing");
                MaxSdk.ShowRewardedAd(_loadedAdUnitId);
            }
            else
            {
                _setStatus("Ad not ready");
            }
        }
        
        protected override void OnAdLoadedEvent(string adUnitId, MaxSdkBase.AdInfo adInfo)
        {
            base.OnAdLoadedEvent(adUnitId, adInfo);
            
            _setStatus($"Loaded {adInfo.NetworkName} {adInfo.NetworkPlacement}");

            _onLoad();
        }
        
        protected override void OnAdFailedEvent(string adUnitId, MaxSdkBase.ErrorInfo errorInfo)
        {
            base.OnAdFailedEvent(adUnitId, errorInfo);
            
            _setStatus("Load failed");
        }
      
     // Example AdConfig
    public class AdConfig
    {
        private string _iosId;
        private string _androidId;
        
        public double _cpm;

        public string Id
        {
            get {
#if UNITY_IOS
                return _iosId;
#else // UNITY_ANDROID
                return _androidId;
#endif
            }
        }

        public AdConfig(string iosId, string androidId, double cpm)
        {
            _iosId = iosId;
            _androidId = androidId;
            _cpm = cpm;
        }
    }
      
      
     // Example usage from application entry point
        private List<AdConfig> _bannerAdUnits = new List<AdConfig>()
        {
            new AdConfig("c04a614bffe76e3c", "4c659b0149dbfbae", 0),
            new AdConfig("c652811b8ad365e0", "43395ac04e228cc7", 50),
            new AdConfig("4ba6a0bb9b47ed6e", "6345b3fa80c73572", 100)
        };
        
        private List<AdConfig> _interstitialAdUnits = new List<AdConfig>
        {
            new AdConfig("6fecb44d5db35b39", "c9e2d5925100354c", 0),
            new AdConfig("d066ee44f5d29f8b", "418322ce01e56e31", 50),
            new AdConfig("d89c87aecdd15c7e", "60bbc7cc56dfa329", 100),
        };
        
        private List<AdConfig> _rewardedAdUnits = new List<AdConfig>
        {
            new AdConfig("2685d8127c299789", "34f72010961b1749", 0),
            new AdConfig("66e16b4b9b8d580a", "21134b4c33e50bd5", 50),
            new AdConfig("08304643cb16df3b", "3082ee9199cf59f0", 100),
        };
      
        private void Awake()
        {
            NeftaAdapterEvents.Init(NeftaId);

            NeftaAdapterEvents.BehaviourInsightCallback = OnBehaviourInsight;
            GetBehaviourInsight();
            
            _banner.Init(_bannerAdUnits, GetBehaviourInsight);
            _interstitial.Init(_interstitialAdUnits, GetBehaviourInsight);
            _rewarded.Init(_rewardedAdUnits, GetBehaviourInsight);

            MaxSdk.SetSdkKey(MaxSdkKey);
            MaxSdk.InitializeSdk();
        }
      
        private void GetBehaviourInsight()
        {
            NeftaAdapterEvents.GetBehaviourInsight(new string[]
            {
                Banner.InsightName,
                Interstitial.InsightName,
                Rewarded.InsightName
            });
        }
        
        private void OnBehaviourInsight(Dictionary<string, Insight> behaviourInsight)
        {
            _banner.OnBehaviourInsight(behaviourInsight);
            _interstitial.OnBehaviourInsight(behaviourInsight);
            _rewarded.OnBehaviourInsight(behaviourInsight);
        }

     // ...
}