---
metadata:
  - name: generator
    content: Diplodoc Platform v5.52.0
alternate:
  - https://ads.yandex.com/helpcenter/en/dev/flutter/rewarded.md
  - https://ads.yandex.com/helpcenter/ru/dev/flutter/rewarded.md
  - https://ads.yandex.com/helpcenter/zh/dev/flutter/rewarded.md
  - href: en/dev/flutter/rewarded.md
    type: text/markdown
    title: Markdown version
  - href: llms.txt
    type: text/markdown
    title: llms.txt
---
> **Documentation Index:** Fetch the complete configuration index at https://ads.yandex.com/helpcenter/en/llms.txt

# Rewarded ads

<!-- source: en/dev/_includes/rewarded.md -->
Rewarded ads are a popular fullscreen ad format where users receive incentives for viewing ads.
<!-- endsource: en/dev/_includes/rewarded.md -->

<!-- source: en/dev/_includes/rewarded.md -->
Ad impressions are opt-in: for example, users can initiate them to get game bonuses or extra lives.
<!-- endsource: en/dev/_includes/rewarded.md -->

<!-- source: en/dev/_includes/rewarded.md -->
Strong user motivation makes this ad format the most popular and profitable adoption in free apps.
<!-- endsource: en/dev/_includes/rewarded.md -->

{% cut "Appearance" %}

{% list tabs %}

- Text and image ads

  <iframe width="200" height="405.5" allow="autoplay" src="https://runtime.strm.yandex.ru/player/video/vplv6tshzb3euhokoa5q?autoplay=1&mute=0&loop=1&loop=1" frameborder="0" allowfullscreen></iframe>

- Video ads

  <iframe width="200" height="405.5" allow="autoplay" src="https://runtime.strm.yandex.ru/player/video/vplvv2aom7x2nte5gckn?autoplay=1&mute=0&loop=1&loop=1" frameborder="0" allowfullscreen></iframe>

{% endlist %}

{% endcut %}

This guide will show how to integrate interstitial ads into a Flutter app.
In addition to code examples and instructions, this guide also contains format-specific recommendations and links to additional resources.

## Prerequisite {#pre}

<!-- source: en/dev/_includes/pre-flutter.md -->
1. Follow the process in [Quick start](https://ads.yandex.com/helpcenter/en/dev/flutter/quick-start.md) to integrate the Yandex Mobile Ads Flutter Plugin.
2. Make sure you're running the latest [Yandex Mobile Ads Flutter Plugin](https://ads.yandex.com/helpcenter/en/dev/platforms.md) version. If you're using mediation, make sure you're running the latest version of the [unified build](https://ads.yandex.com/helpcenter/en/dev/platforms.md).
<!-- endsource: en/dev/_includes/pre-flutter.md -->

## Implementation {#implement}

Key steps for integrating rewarded ads:

* Create and configure the `RewardedAdLoader` ad loader.
* Load the `RewardedAd` ad.
* Register the `RewardedAdEventListener` listener for ad callback methods.
* Render the `RewardedAd`.
* Reward the user for viewing the ad.

## Features of rewarded ad integration {#features}

If you received an error in the `onAdFailedToLoad()` callback, don't try to load a new ad again. If there's no other option, limit the number of ad load retries. That will help avoid constant unsuccessful requests and connection issues when limitations arise.

## Loading ads

To load rewarded ads, create the `RewardedAdLoader` object.

You will need the ad unit ID from the Yandex Advertising Network interface (adUnitId).

You can expand the set of ad request parameters via `AdRequest`, passing user interests, contextual app data, location details, or other data. Delivering additional contextual data in the request can significantly improve your ad quality. Read more in the [Ad Targeting](https://ads.yandex.com/helpcenter/en/dev/flutter/target.md) section.

The following example shows how to load a rewarded ad:

```dart
final _adLoader = RewardedAdLoader();
RewardedAd? _ad;

@override
void initState() {
  super.initState();
  YandexAds.initialize();
  _loadRewardedAd();
}

Future<void> _loadRewardedAd() async {
  try {
    _ad = await _adLoader.loadAd(
      adRequest: AdRequest(adUnitId: 'R-M-XXXXXX-Y'), // For debugging, you can use 'demo-rewarded-yandex'
    );
  } on AdRequestError catch (error) {
    // Ad failed to load with AdRequestError.
    // Attempting to load a new ad from the error handler is strongly discouraged.
  }
}
```

## Ad rendering

Rewarded advertising is an incentive-based ad format that gives users a reward after they view the ad. The reward could be an extra life or advancing to the next level in a game. The reward format is determined at the app level.

To track the rewarded ad lifecycle and issue rewards, set the `RewardedAdEventListener` callback method listener for the `RewardedAd` object.

To show a rewarded ad, use the `show()` method. To wait until viewing is complete, use the `waitForDismiss()` method:

```dart
_showAd() async {
  _ad?.setAdEventListener(
      eventListener: RewardedAdEventListener(
    onAdShown: () {
      // Called when an ad is shown.
    },
    onAdFailedToShow: (error) {
      // Called when an ad failed to show.
      // Destroy the ad so you don't show the ad a second time.
      _ad?.destroy();
      _ad = null;

      // Now you can preload the next ad.
      _loadRewardedAd();
    },
    onAdClicked: () {
      // Called when a click is recorded for an ad.
    },
    onAdDismissed: () {
      // Called when ad is dismissed.
      // Destroy the ad so you don't show the ad a second time.
      _ad?.destroy();
      _ad = null;

      // Now you can preload the next ad.
      _loadRewardedAd();
    },
    onAdImpression: (impressionData) {
      // Called when an impression is recorded for an ad.
    },
    onRewarded: (Reward reward) {
      // Called when the user can be rewarded.
    }
  ));

  await _ad?.show();
  final reward = await _ad?.waitForDismiss();
  if (reward != null) {
    print('got ${reward.amount} of ${reward.type}');
  }
}
```

## Releasing resources

Call the `destroy()` method for previously shown ads. That releases the resources and prevents memory leaks.

Don't store links to previously rendered ads.

You can use the `onAdDismissed` callback method for the following actions:

```dart
_ad?.setAdEventListener(
    eventListener: RewardedAdEventListener(
        //...
        onAdDismissed: () {
          _ad?.destroy();
          _ad = null;
        },
        //...
    ));
```

## Testing the rewarded ad integration {#test}

{% list tabs %}

- Android

   <!-- source: en/dev/_includes/test-android-rewarded.md -->
   ### Using demo ad units for ad testing {#demo-blocks}

   Use test ads to check your rewarded ad integration and the app itself. To make sure that test ads are returned for each ad request, you can use a special demo ad placement ID.

   Demo adUnitId: `demo-rewarded-yandex`.

   {% note warning %}

   Before publishing your app in the store, make sure to replace the demo placement ID with the real ID you obtained in the Yandex Advertising Network interface.

   {% endnote %}

   For the list of all available demo ad placement IDs, see [Demo ad units for testing](https://ads.yandex.com/helpcenter/en/dev/android/demo-blocks.md).

   ### Testing ad integration {#test-int}

   You can check if your rewarded ads are integrated correctly using the SDK's built-in analyzer. A detailed report with the test results will appear in the log.

   To view the report, search for the keyword “YandexAds” in [Logcat](https://developer.android.com/studio/command-line/logcat), a tool for debugging Android apps.
   ```bash
   adb logcat -v brief '*:S YandexAds'
   ```

   If the integration is successful, the following message is returned:
   ```bash
   adb logcat -v brief '*:S YandexAds'
   mobileads$ adb logcat -v brief '*:S YandexAds'
   I/YandexAds(13719): [Integration] Ad type rewarded was integrated successfully
   ```

   If there are any rewarded ad integration issues, you'll get a detailed issue report and troubleshooting recommendations.
   <!-- endsource: en/dev/_includes/test-android-rewarded.md -->

- iOS

   ### Using demo ad units for ad testing

   <!-- source: en/dev/_includes/test-ios-rewarded.md -->
   We recommend using test ads to test your ad integration and your app itself.

   To guarantee that test ads are returned for every ad request, we created a special demo ad placement ID. Use it to check your ad integration.

   Demo adUnitId: `demo-rewarded-yandex`.

   {% note warning %}

   Before publishing your app to the store, make sure you replace the demo ad unit ID with a real one obtained from the Yandex Advertising Network interface.

   {% endnote %}

   You can find the list of available demo ad placement IDs in the [Demo ad units for testing](https://ads.yandex.com/helpcenter/en/dev/ios/demo-blocks.md) section.
   <!-- endsource: en/dev/_includes/test-ios-rewarded.md -->

   ### Testing ad integration

   <!-- source: en/dev/_includes/test-integration-ios.md -->
   You can test your ad integration using the native Console tool.

   To view detailed logs, call the `YandexAds` class's `enableLogging` method.

   ```swift
   YandexAds.enableLogging()
   ```

   To view SDK logs, go to the Console tool and set `Subsystem = com.mobile.ads.ads.sdk`. You can also filter logs by category and error level.

   If you're having problems integrating ads, you'll get a detailed report on the issues and recommendations for how to fix them.

   <img src= "https://yastatic.net/s3/doc-binary/src/dev/mobile-ads/common/integration-ios-2.png">
   <!-- endsource: en/dev/_includes/test-integration-ios.md -->

{% endlist %}

## Tips

### Ad preloading

<!-- source: en/dev/_includes/preload.md -->
Loading an ad may take several seconds, depending on the number of ad networks connected in mobile mediation and the user's internet speed. We recommend preloading ads before displaying them.
<!-- endsource: en/dev/_includes/preload.md -->

Call `load` in advance to display the loaded ad at the right moment.

To start loading the next ad right after serving the current one, bind this process to the `onAdDismissed()` event.

<!-- source: en/dev/_includes/cash-ads.md -->
If you cache ads on too many screens that are unlikely to be shown, your ad effectiveness could drop. For example, if users complete 2-3 game levels per session, you shouldn't cache ads for 6-7 screens. Your ad viewability could decrease otherwise, and the advertising system might deprioritize your app.

To make sure you're finding a good balance for your app, track the "Share of impressions" or "Share of visible impressions" metric in the Yandex Advertising Network interface. If it's under 20%, you should probably revise your caching algorithm. The higher the percentage of impressions, the better.
<!-- endsource: en/dev/_includes/cash-ads.md -->

## Additional resources {#resources}

* <!-- source: en/dev/_includes/github-pubdev-links.md -->
  Link to [pub.dev](https://pub.dev/packages/yandex_mobileads/example).
  <!-- endsource: en/dev/_includes/github-pubdev-links.md -->