Request error no ad to show

Interstitial ads are full-screen ads that cover the interface of an app until
closed by the user. They’re typically displayed at natural transition points in
the flow of an app, such as between activities or during the pause between
levels in a game. When an app shows an interstitial ad, the user has the choice
to either tap on the ad and continue to its destination or close it and return
to the app.

This guide shows you how to integrate interstitial ads into an iOS app.

Prerequisites

• Google Mobile Ads SDK 8.0.0 or higher.
• Complete the Get started guide.

Always test with test ads

When building and testing your apps, make sure you use test ads rather than
live, production ads. Failure to do so can lead to suspension of your account.

The easiest way to load test ads is to use our dedicated test ad unit ID
for iOS interstitials:
/6499/example/interstitial

It’s been specially configured to return test ads for every request, and you’re
free to use it in your own apps while coding, testing, and debugging. Just make
sure you replace it with your own ad unit ID before publishing your app.

For more information about how the Mobile Ads SDK’s test ads work, see
Test Ads.

Implementation

The main steps to integrate interstitial ads are:

1. Load an ad.
2. Register for callbacks.
3. Display the ad and handle the reward event.

Load an ad

Loading an ad is accomplished using the static
loadWithAdUnitID:request:completionHandler: method on the
GAMInterstitialAd class. The load method requires
your ad unit ID, a GAMRequest object, and a
completion handler which gets called when ad loading succeeds or fails. The
loaded GAMInterstitialAd object is provided as a
parameter in the completion handler. The below example shows how to load a
GAMInterstitialAd in your ViewController class.

import GoogleMobileAds
import UIKit

class ViewController: UIViewController {

  private var interstitial: GAMInterstitialAd?

  override func viewDidLoad() {
    super.viewDidLoad()
    let request = GAMRequest()
    GAMInterstitialAd.load(withAdUnitID:"/6499/example/interstitial",
                                request: request,
                      completionHandler: { [self] ad, error in
                        if let error = error {
                          print("Failed to load interstitial ad with error: (error.localizedDescription)")
                          return
                        }
                        interstitial = ad
                      }
    )
  }
}

@import GoogleMobileAds;
@import UIKit;

@interface ViewController ()

@property(nonatomic, strong) GAMInterstitialAd *interstitial;

@end

@implementation ViewController

- (void)viewDidLoad {
  [super viewDidLoad];
  GAMRequest *request = [GAMRequest request];
  [GAMInterstitialAd loadWithAdUnitID:@"/6499/example/interstitial"
                              request:request
                    completionHandler:^(GAMInterstitialAd *ad, NSError *error) {
    if (error) {
      NSLog(@"Failed to load interstitial ad with error: %@", [error localizedDescription]);
      return;
    }
    self.interstitial = ad;
  }];
}

Register for callbacks

In order to receive notifications for presentation events, you must implement
the GADFullScreenContentDelegate protocol and assign it to the
fullScreenContentDelegate property of the returned ad. The
GADFullScreenContentDelegate protocol handles callbacks for when the ad
presents successfully or unsuccessfully, and when it is dismissed. The following
code shows how to implement the protocol and assign it to the ad:

class ViewController: UIViewController, GADFullScreenContentDelegate {

  private var interstitial: GAMInterstitialAd?

  override func viewDidLoad() {
    super.viewDidLoad()
    let request = GAMRequest()
    GAMInterstitialAd.load(withAdUnitID:"/6499/example/interstitial",
                                request: request,
                      completionHandler: { [self] ad, error in
                        if let error = error {
                          print("Failed to load interstitial ad with error: (error.localizedDescription)")
                          return
                        }
                        interstitial = ad
                        interstitial?.fullScreenContentDelegate = self
                      }
    )
  }

  /// Tells the delegate that the ad failed to present full screen content.
  func ad(_ ad: GADFullScreenPresentingAd, didFailToPresentFullScreenContentWithError error: Error) {
    print("Ad did fail to present full screen content.")
  }

  /// Tells the delegate that the ad will present full screen content.
  func adWillPresentFullScreenContent(_ ad: GADFullScreenPresentingAd) {
    print("Ad will present full screen content.")
  }

  /// Tells the delegate that the ad dismissed full screen content.
  func adDidDismissFullScreenContent(_ ad: GADFullScreenPresentingAd) {
    print("Ad did dismiss full screen content.")
  }
}

@interface ViewController ()<GADFullScreenContentDelegate>

@property(nonatomic, strong) GAMInterstitialAd *interstitial;

@end

@implementation ViewController
- (void)viewDidLoad {
  [super viewDidLoad];
  GAMRequest *request = [GAMRequest request];
  [GAMInterstitialAd loadWithAdUnitID:@"/6499/example/interstitial"
                              request:request
                    completionHandler:^(GAMInterstitialAd *ad, NSError *error) {
    if (error) {
      NSLog(@"Failed to load interstitial ad with error: %@", [error localizedDescription]);
      return;
    }
    self.interstitial = ad;
    self.interstitial.fullScreenContentDelegate = self;
  }];
}

/// Tells the delegate that the ad failed to present full screen content.
- (void)ad:(nonnull id<GADFullScreenPresentingAd>)ad
didFailToPresentFullScreenContentWithError:(nonnull NSError *)error {
    NSLog(@"Ad did fail to present full screen content.");
}

/// Tells the delegate that the ad will present full screen content.
- (void)adWillPresentFullScreenContent:(nonnull id<GADFullScreenPresentingAd>)ad {
    NSLog(@"Ad will present full screen content.");
}

/// Tells the delegate that the ad dismissed full screen content.
- (void)adDidDismissFullScreenContent:(nonnull id<GADFullScreenPresentingAd>)ad {
   NSLog(@"Ad did dismiss full screen content.");
}

GAMInterstitialAd is a one-time-use object. This
means that once an interstitial ad is shown, it cannot be shown again. A best
practice is to load another interstitial ad in the
adDidDismissFullScreenContent: method on GADFullScreenContentDelegate so
that the next interstitial ad starts loading as soon as the previous one is
dismissed.

Display the ad

Interstitials should be displayed during natural pauses in the flow of an app.
Between levels of a game is a good example, or after the user completes a task.
Here’s an example of how to do this in one of the action methods in a
UIViewController:

@IBAction func doSomething(_ sender: Any) {
  if interstitial != nil {
    interstitial.present(fromRootViewController: self)
  } else {
    print("Ad wasn't ready")
  }
}

- (IBAction)doSomething:(id)sender {
  ...
  if (self.interstitial) {
    [self.interstitial presentFromRootViewController:self];
  } else {
    NSLog(@"Ad wasn't ready");
  }
}

If you’re not getting any ads back, with the error response «Request Error: No
ads to show», make sure your line item has a creative targeted to the right
size. Interstitial sizes are 320×480 & 480×320 for phones and 1024×768 &
768×1024 for tablets. If a device isn’t big enough to fit a 1024×768 or
768×1024, it will fall back to the 320×480 or 480×320 size.

Best practices

Consider whether interstitial ads are the right type of ad for your app.

Interstitial ads work best in apps with natural transition points.
The conclusion of a task within an app, like sharing an image or completing a
game level, creates such a point. Because the user is expecting a break in the
action, it’s easy to present an interstitial ad without disrupting their
experience. Make sure you consider at which points in your app’s workflow you’ll
display interstitial ads and how the user is likely to respond.

Remember to pause the action when displaying an interstitial ad.

There are a number of different types of interstitial ads: text, image,
video, and more. It’s important to make sure that when your app displays an
interstitial ad, it also suspends its use of some resources to allow the ad to
take advantage of them. For example, when you make the call to display an
interstitial ad, be sure to pause any audio output being produced by your app.
You can resume playing sounds in the
adDidDismissFullScreenContent:
event handler, which will be invoked when the user has finished interacting
with the ad. In addition, consider temporarily halting any intense computation
tasks (such as a game loop) while the ad is being displayed. This will ensure
that the user doesn’t experience slow or unresponsive graphics or stuttered
video.

Allow for adequate loading time.

Just as it’s important to make sure you display interstitial ads at an
appropriate time, it’s also important to make sure the user doesn’t have to
wait for them to load. Loading the ad in advance before you intend to show
can ensure that your app has a fully loaded interstitial ad at the ready when
the time comes to display one.

Don’t flood the user with ads.

While increasing the frequency of interstitial ads in your app might seem
like a great way to increase revenue, it can also degrade the user experience
and lower clickthrough rates. Make sure that users aren’t so frequently
interrupted that they’re no longer able to enjoy the use of your app.

Don’t use the load completion callback to show the interstitial.

This can cause a poor user experience. Instead, pre-load the ad before you
need to show it. Then check the canPresentFromRootViewController:error: method
on GAMInterstitialAd to find out if it is ready to be
shown.

Examples on GitHub

• Interstitial ads example:
  Swift |
  Objective-C

Next steps

• Learn about ad targeting and
  interstitial ad guidelines.