# Implement rewarded ads in iOS

> Implement rewarded ads in your iOS app. Load ad content, display it through Objective-C or Swift code, and use a delegate to manage ad events and reward logic.

Rewarding players for watching ads increases user engagement, resulting in higher revenue. For example, games might reward users with in-game currency, consumables, additional lives, or experience-multipliers. For more information on how to effectively design your rewarded ads, refer to the [monetization strategy](/monetization/getting-started/monetization-strategy.md) guide.

## Rewarded video ad load example

Use `UADSLoadConfigurationBuilder` to construct a load request with the placement ID, optional mediation metadata, and optional ad markup for bidding, then pass it to `UADSRewardedAd.load()`. The completion block receives the loaded `UADSRewardedAd` instance on success. Retain it, as it's required to show the ad later, or an error object on failure.

The example includes mediation metadata and ad markup, which only mediation adapters set. If you integrate Unity Ads directly, omit both values.

Ads expire a set time after they load if they aren't shown. Assign `onAdExpired` on the loaded ad instance to detect this. Attempting to `show()` an expired rewarded ad fails, which is especially important to catch since rewarded ads are often preloaded and held until the user requests a reward. Use the callback to clear your stored reference and issue a new `load()` call so a fresh ad is ready when needed.

1. **Objective-C**

   ```objective-c
   @property (strong) UADSRewardedAd *rewardedAd;

   UADSLoadConfigurationBuilder *builder =
       [[UADSLoadConfigurationBuilder alloc] initWithPlacementId:placementId];
   builder = [builder withMediationInfo:self.mediationInfo];
   builder = [builder withAdMarkup:bidResponse];

   [UADSRewardedAd load:[builder build]
           completion:^(UADSRewardedAd *ad, id<UnityAdsError> error) {
       if (error) {
           // Handle error
       } else {       
            __weak typeof(self) weakSelf = self;
            ad.onAdExpired = ^(UnityAd *expiredAd) {
             weakSelf.rewardedAd = nil;
             // reload here
           };
       }
   }];
   ```

2. **Swift**

   ```swift
   var rewardedAd: UADSRewardedAd?

   let config = UADSLoadConfigurationBuilder(placementId: placementId)
     .with(mediationInfo: mediationInfo)
     .with(adMarkup: bidResponse)
     .build()

   UADSRewardedAd.load(config) { ad, error in
     if let error = error {
         // Handle error
     } else {
         self.rewardedAd = ad
         ad?.onAdExpired = { [weak self] _ in
         self?.rewardedAd = nil
         // reload here
         }
     }
   }
   ```

## Rewarded video ad show and reward handling example

Call `show()` on the retained `UADSRewardedAd` instance, passing a `UADSShowConfiguration` built with the presenting view controller, and a `UADSRewardedShowDelegate`. In addition to the standard `showDidStart`, `showDidClick`, `showDidComplete`, and `showDidFail` callbacks, the delegate provides a dedicated `showDidReceiveReward` callback that fires when the user earns a reward. Grant the reward in `showDidReceiveReward` rather than in `showDidComplete` to avoid conditional completion-state checks.

1. **Objective-C**

   ```objective-c
   @interface MyDelegate : NSObject <UADSRewardedShowDelegate>
   @end

   @implementation MyDelegate
   - (void)showDidStart:(UADSRewardedAd *)unityAd {}
   - (void)showDidClick:(UADSRewardedAd *)unityAd {}
   - (void)showDidComplete:(UADSRewardedAd *)unityAd
                     with:(UADSShowFinishState)finishState {
   }
   - (void)showDidFail:(UADSRewardedAd *)unityAd
               error:(id<UnityAdsError>)error {}
   - (void)showDidReceiveReward:(UADSRewardedAd *)unityAd {
     // reward callback
   }
   @end

   UADSShowConfigurationBuilder *builder =
   [[UADSShowConfigurationBuilder alloc] init];
   builder = [builder withViewController:viewController];

   [self.rewardedAd show:[builder build] delegate:delegate];
   ```

2. **Swift**

   ```swift
   class MyDelegate: NSObject, UADSRewardedShowDelegate {
   func showDidStart(_ unityAd: UADSRewardedAd) {}

   func showDidClick(_ unityAd: UADSRewardedAd) {}

   func showDidComplete(
       _ unityAd: UADSRewardedAd,
       with finishState: UADSShowFinishState
   ) {
   }

   func showDidFail(
       _ unityAd: UADSRewardedAd,
       error: UnityAdsError
   ) {}

   func showDidReceiveReward(_ unityAd: UADSRewardedAd) {
       // reward callback
     }
   }

   let config = UADSShowConfigurationBuilder()
     .with(viewController: viewController)
     .build()

   rewardedAd?.show(config, delegate: delegate)
   ```

**Next steps**: To expand your implementation, refer to [Implement banner ads in iOS](/ads-ios/4.20.0/sdk-integration/banner-ads.md).