App Open Ads

AppLovin SDK v11.5.0 introduces the app open ad format. App open ads are similar to interstitial ads but show when the user soft launches or cold starts the app:

Cold start

creating new session of the app on device

• the app is not in device memory
• splash/loading screen required

Soft launch

bringing the app from background to foreground, or turning the phone on when the app is in foreground mode

• the app is suspended in memory
• splash/loading screen required

Note

Fire OS Applications are not supported.

Best Practices

• Use a splash/loading screen before the app open ad shows. Do this no matter how the ad is placed within the app.
  • Include a call-out to the user that tells them they will see an ad within the Splash/Loading screen.
    • For example: “Watch an ad from their sponsor while the app loads.”
  • Ensure that the user is not exposed to actual app content before the ad shows. The correct sequence is: splash/loading screen ⇒ app open ad ⇒ app content.
• Ensure that AppLovin’s SDK initializes before you load an app open ad.
• When an app open ad is not yet loaded (i.e. on cold start), load it first. Load any other ad formats later so that you avoid loading them in parallel with the app open ad.
  • Loading multiple ad formats in parallel is not good for the device’s resources or for ad demand SDKs.
• To avoid over-exposing users to App Open Ads, AppLovin suggests that you consider the following strategies:
  • Use a frequency cap that you manage outside of AppLovin. This way you have full control over when the ads will serve.
  • Implement a cool down period based on user behavior in the app. For example: don’t show an ad during soft launch for some period of time before you show one again, or show an ad only during every other soft launch.
  • Wait until new users open the app and use it a few times before you show the first App Open Ad.

Retention

Always consider retention when you implement the App Open Ad format.

For app open ads, you can choose from a variety of implementation strategies.

AppLovin recommends that you test by using one or more of the techniques described below. Each application has a unique configuration that allows it to maximize revenue without impacting retention or time spent in the app. User behavior and engagement may change over time, so AppLovin recommends that you retest your App Open Ads strategies regularly. Some implementation techniques you may use to test App Open Ads include:

• Show to the right users. Examples of this technique include:
  • Wait a variable number of days after initial install to show on cold start.
  • Only show to users that have had a session in the last several days.
  • Only show to users that have reached certain criteria in the app. For example they have completed a certain level, they have opened the app a certain number of times, or they do not engage with Rewarded offerings.
• Avoid over-exposing ads to users. Examples of this technique include:
  • Do not show an ad on every opportunity. Instead, show on every other, third, or fourth ad opportunity.
  • Only show an ad if the app is backgrounded for a certain amount of time (i.e. 30 seconds, 2 minutes, 15 minutes).
  • If you show a cold start ad, do not show soft launch app open ads or interstitials for a certain amount of time.
  • Use a frequency cap. If possible, tailor that cap according to the user cohort.
• Use a splash screen to inform the user.
  • Refer to the section on splash screens in “Best Practices” above.

Using an App Open Ad

To ensure your app open ad is ready when your application is brought to the foreground, you need to preload a MAAppOpenAd. Create a method that shows an ad if one is ready. Call that method inside applicationDidBecomeActive:.

Your app then attempts to show an ad on app open, or loads an ad if one is not not preloaded.

Cold Starts and Loading Screens

There may be a delay between when you request an ad and receive an ad to show. This can cause the user to briefly see your app before being surprised by an out-of-context ad. You should avoid this, as it is a bad user experience. The preferred way to handle cold starts is to use a loading screen to precede any initial app content, and to show the ad from the loading screen. If the app shows any of your app content after the loading screen, do not show the ad.

You may have a loading screen under the app open ad, and that loading screen completes before the ad is dismissed. In such a case, you can dismiss your loading screen in the didHide method.

Examples

These code examples assume that app open ads are shown only on “soft lauch” when your app is suspended in memory. They do not include the splash/loading screen. You must handle the splash/loading screen—see Best Practices.

Objective-C

@interface AppDelegate()<MAAdDelegate>
@property (nonatomic, strong) MAAppOpenAd *appOpenAd;
@end

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
  [[ALSdk shared] initializeSdkWithCompletionHandler:^(ALSdkConfiguration *configuration) {
    self.appOpenAd = [[MAAppOpenAd alloc] initWithAdUnitIdentifier: @"«ad-unit-ID»"];
    self.appOpenAd.delegate = self;
    [self.appOpenAd loadAd];
  }]

  return YES;
}

- (void)applicationDidBecomeActive:(UIApplication *)application
{
  [self showAdIfReady];
}

- (void)showAdIfReady
{
  if ( ![[ALSdk shared] isInitialized] )
  {
    return;
  }

  if ( [self.appOpenAd isReady] )
  {
    [self.appOpenAd showAdForPlacement: @"«test-placement-ID»"];
  }
  else
  {
    [self.appOpenAd loadAd];
  }
}

- (void)didLoadAd:(MAAd *)ad {}
- (void)didFailToLoadAdForAdUnitIdentifier:(NSString *)adUnitIdentifier withError:(MAError *)error {}
- (void)didDisplayAd:(MAAd *)ad {}
- (void)didClickAd:(MAAd *)ad {}

- (void)didHideAd:(MAAd *)ad
{
  [self.appOpenAd loadAd];
}

- (void)didFailToDisplayAd:(MAAd *)ad withError:(MAError *)error
{
  [self.appOpenAd loadAd];
}

@end

Swift

@UIApplicationMain
class AppDelegate: UIApplicationDelegate
{
  private lazy var appOpenAd = MAAppOpenAd(adUnitIdentifier: "«ad-unit-ID»")

  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool
  {
    ALSdk.shared().initializeSdk { (configuration: ALSdkConfiguration) in
      appOpenAd.delegate = self
      appOpenAd.load()
    }

    return true
  }

  func applicationDidBecomeActive(_ application: UIApplication)
  {
    showAdIfReady()
  }

  private func showAdIfReady()
  {
    if ALSdk.shared().isInitialized
    {
      return
    }

    if appOpenAd.isReady
    {
      appOpenAd.show(forPlacement: "«test-placement-ID»")
    }
    else
    {
      appOpenAd.load()
    }
  }
}

extension AppDelegate : MAAdDelegate
{
  func didLoad(_ ad: MAAd) {}
  func didFailToLoadAd(forAdUnitIdentifier adUnitIdentifier: String, withError error: MAError) {}
  func didDisplay(_ ad: MAAd) {}
  func didClick(_ ad: MAAd) {}

  func didHide(_ ad: MAAd)
  {
    appOpenAd.load()
  }

  func didFail(toDisplay ad: MAAd, withError error: MAError)
  {
    appOpenAd.load()
  }
}

Supported Adapter Versions

Ad Network	Minimum Adapter Version
Google Bidding and Google AdMob	10.9.0.1
Liftoff Monetize	6.12.0.3
Mintegral	7.2.3.0.1
Pangle	4.6.2.2.1