diff --git a/prebid-mobile/modules/rendering/android-sdk-integration-pb.md b/prebid-mobile/modules/rendering/android-sdk-integration-pb.md
index 9215c191c5..4c221aaee0 100644
--- a/prebid-mobile/modules/rendering/android-sdk-integration-pb.md
+++ b/prebid-mobile/modules/rendering/android-sdk-integration-pb.md
@@ -17,7 +17,7 @@ You can use Prebid SDK to monetize your app with a custom ad server or even with
 
 ## Transport API
 
-The default ad server for Prebid's Mobile SDK is GAM. The SDK can be expanded to include support for 3rd party ad servers through the fetchDemand function. This function returns the Prebid Server bidder key/values (targeting keys), which can then be passed to the ad server of choice. 
+The default ad server for Prebid's Mobile SDK is GAM. The SDK can be expanded to include support for 3rd party ad servers through the fetchDemand function. This function returns the Prebid Server bidder key/values (targeting keys), which can then be passed to the ad server of choice.
 
 In this mode, the publisher will be responsible for the following actions:
 
@@ -39,46 +39,43 @@ This approach is avaliable for the following ad formats:
 The basic integration steps for these ad units you can find at the page for integration using [Original API](/prebid-mobile/pbm-api/android/android-sdk-integration-gam-original-api.html). The diference is that you should use  the `fetchDemand` function with following signature:
 
 ```kotlin
-public void fetchDemand(@NonNull Object adObj, 
-                        @NonNull OnCompleteListener2 listener) { ... }
-                        
-public interface OnCompleteListener2 {
-    /**
-     * This method will be called when PrebidMobile finishes attaching keywords to unmodifiableMap.
-     * @param resultCode see {@link ResultCode} class definition for details
-     * @param unmodifiableMap a map of targeting Key/Value pairs
-     */
-    @MainThread
-    void onComplete(ResultCode resultCode, 
-                    @Nullable Map<String, String> unmodifiableMap);
-}                        
+public void fetchDemand(OnFetchDemandResult listener) { ... }
+
+public interface OnFetchDemandResult {
+    void onComplete(@NonNull BidInfo bidInfo);
+}
 ```
 
 Examples:
 
-```kotlin
-private fun loadRewardedVideo() {
-    adUnit?.fetchDemand { resultCode, unmodifiableMap -> 
-        val keywords: Map<String, String> = HashMap(unmodifiableMap)
+``` kotlin
+adUnit?.fetchDemand { result ->
+    if(result.getResultCode() == ResultCode.SUCCESS) {
+        val keywords = resultCode.targetingKeywords
 
-        adServerObject.loadRewardedVideo(ADUNITID_REWARDED, keywords)
+        makeAdRequest(keywords)
     }
 }
 ```
 
+The `BidInfo` provides the following properties:
+
+* `resultCode` - the object of type `ResultCode` describing the status of the bid request.
+* `targetingKeywords` - the targeting keywords of the winning bid
+* `exp` - the number of seconds that may elapse between the auction and the actual impression. In this case, it indicates the approximate TTL of the bid in the Prebid Cache. Note that the actual expiration time of the bid will be less than this number due to the network and operational overhead. The Prebid SDK doesn't make any adjustments to this value.
+* `nativeAdCacheId` - the local cache ID of the winning bid. Applied only to the `native` ad format.
+
 ## Rendering API
 
-The integration and usage of the Rendering API is similar to any other Ad SDK. It sends the bid requests to the Prebid Server and renders the winning bid. 
+The integration and usage of the Rendering API is similar to any other Ad SDK. It sends the bid requests to the Prebid Server and renders the winning bid.
 
 ![Rendering with GAM as the Primary Ad Server](/assets/images/prebid-mobile/modules/rendering/Prebid-In-App-Bidding-Overview-Pure-Prebid.png)
 
-
 ### Banner API
 
 Integration example:
 
-
-```kotlin
+``` kotlin
 // 1. Create an Ad View
 bannerView = BannerView(requireContext(), configId, adSize)
 bannerView?.setBannerListener(this)
@@ -90,8 +87,8 @@ viewContainer?.addView(bannerView)
 bannerView?.loadAd()
 ```
 
-{% capture warning_note %}  
-Pay attention that the `loadAd()` should be called on the main thread. 
+{% capture warning_note %}
+Pay attention that the `loadAd()` should be called on the main thread.
 {% endcapture %}
 {% include /alerts/alert_warning.html content=warning_note %}
 
@@ -100,23 +97,23 @@ Pay attention that the `loadAd()` should be called on the main thread.
 
 Initialize the `BannerAdView` with properties:
 
-- `configId` - an ID of a [Stored Impression](/prebid-server/features/pbs-storedreqs.html) on the Prebid server
-- `size` - the size of the ad unit which will be used in the bid request.
+* `configId` - an ID of a [Stored Impression](/prebid-server/features/pbs-storedreqs.html) on the Prebid server
+* `size` - the size of the ad unit which will be used in the bid request.
 
 #### Step 2: Load the Ad
 {:.no_toc}
 
 Call `loadAd()` and SDK will:
 
-- make bid request to Prebid
-- render the winning bid on display
+* make bid request to Prebid
+* render the winning bid on display
 
 #### Outstream Video
 {:.no_toc}
 
 For **Banner Video** you will also need to specify the `bannerView.videoPlacementType`:
 
-```kotlin
+``` kotlin
 bannerView.videoPlacementType = PlacementType.IN_BANNER // or any other available type
 ```
 
@@ -124,7 +121,7 @@ bannerView.videoPlacementType = PlacementType.IN_BANNER // or any other availabl
 
 Integration example:
 
-```kotlin
+``` kotlin
 // 1. Create an Interstitial Ad Unit
 interstitialAdUnit = InterstitialAdUnit(requireContext(), configId, minSizePercentage)
 interstitialAdUnit?.setInterstitialAdUnitListener(this)
@@ -137,27 +134,27 @@ interstitialAdUnit?.loadAd()
 interstitialAdUnit?.show()
 ```
 
-{% capture warning_note %}  
-Pay attention that the `loadAd()` should be called on the main thread. 
+{% capture warning_note %}
+Pay attention that the `loadAd()` should be called on the main thread.
 {% endcapture %}
 {% include /alerts/alert_warning.html content=warning_note %}
 
 The **default** ad format for interstitial is **DISPLAY**. In order to make a `multiformat bid request`, set the respective values into the `adUnitFormats` parameter.
 
-```
+``` kotlin
 interstitialAdUnit = InterstitialAdUnit(
-                        requireContext(), 
-                        configId, 
+                        requireContext(),
+                        configId,
                         EnumSet.of(AdUnitFormat.BANNER, AdUnitFormat.VIDEO))
 ```
 
 #### Step 1: Create an Ad Unit
 {:.no_toc}
 
-Initialize the `InterstitialAdUnit ` with properties:
+Initialize the `InterstitialAdUnit` with properties:
 
-- `configId` - an ID of a [Stored Impression](/prebid-server/features/pbs-storedreqs.html) on the Prebid server
-- `minSizePercentage` - specifies the minimum width and height percent an ad may occupy of a device’s real estate.
+* `configId` - an ID of a [Stored Impression](/prebid-server/features/pbs-storedreqs.html) on the Prebid server
+* `minSizePercentage` - specifies the minimum width and height percent an ad may occupy of a device’s real estate.
 
 You can also assign the listener for processing ad events.
 
@@ -173,7 +170,7 @@ Call the `loadAd()` to make a bid request.
 
 Wait until the ad is loaded and present it to the user in any suitable time.
 
-```kotlin
+``` kotlin
 override fun onAdLoaded(interstitialAdUnit: InterstitialAdUnit) {
     //Ad is ready for display
 }
@@ -183,11 +180,11 @@ override fun onAdLoaded(interstitialAdUnit: InterstitialAdUnit) {
 
 Integration example:
 
-```kotlin
+``` kotlin
 // 1. Create an Ad Unit
 rewardedAdUnit = RewardedAdUnit(requireContext(), configId)
 rewardedAdUnit?.setRewardedAdUnitListener(this)
-    
+
 // 2. Execute the loadAd function
 rewardedAdUnit?.loadAd()
 
@@ -197,8 +194,8 @@ rewardedAdUnit?.loadAd()
 rewardedAdUnit?.show()
 ```
 
-{% capture warning_note %}  
-Pay attention that the `loadAd()` should be called on the main thread. 
+{% capture warning_note %}
+Pay attention that the `loadAd()` should be called on the main thread.
 {% endcapture %}
 {% include /alerts/alert_warning.html content=warning_note %}
 
@@ -207,7 +204,7 @@ Pay attention that the `loadAd()` should be called on the main thread.
 
 Create the `RewardedAdUnit` object with parameters:
 
-- `adUnitId` - an ID of Stored Impression on the Prebid server.
+* `adUnitId` - an ID of Stored Impression on the Prebid server.
 
 #### Step 2: Load the Ad
 {:.no_toc}
@@ -219,7 +216,7 @@ Call the `loadAd()` to make a bid request.
 
 Wait until the ad is loaded and present it to the user in any suitable time.
 
-```kotlin
+``` kotlin
 override fun onAdLoaded(rewardedAdUnit: RewardedAdUnit) {
 //Ad is ready for display
 }
diff --git a/prebid-mobile/modules/rendering/ios-sdk-integration-pb.md b/prebid-mobile/modules/rendering/ios-sdk-integration-pb.md
index 5282ec6b82..8fe5952a0f 100644
--- a/prebid-mobile/modules/rendering/ios-sdk-integration-pb.md
+++ b/prebid-mobile/modules/rendering/ios-sdk-integration-pb.md
@@ -17,17 +17,17 @@ You can use Prebid SDK to monetize your app with a custom ad server or even with
 
 ## Transport API
 
-The default ad server for Prebid's Mobile SDK is GAM. The SDK can be expanded to include support for 3rd party ad servers through the fetchDemand function. This function returns the Prebid Server bidder key/values (targeting keys), which can then be passed to the ad server of choice. 
+The default ad server for Prebid's Mobile SDK is GAM. The SDK can be expanded to include support for 3rd party ad servers through the fetchDemand function. This function returns additional bid information like Prebid Server bidder key/values (targeting keys), which can then be passed to the ad server of choice.
 
 In this mode, the publisher will be responsible for the following actions:
 
-* Call fetchDemand with extended targetingDict callback
-* Retrieve targeting keys from extended fetchDemand function
+* Call the `fetchDemand` method with specific callback
+* Retrieve targeting keys from the `BidInfo` callback parameter
 * Convert targeting keys into the format for your ad server
 * Pass converted keys to your ad server
 * Render ad with Prebid Universal Creative or custom renderer
 
-This approach is avaliable for the following ad formats:
+This approach is available for the following ad formats:
 
 * Display Banner via `BannerAdUnit`
 * Video Banner and Instream Video via `VideoAdUnit`
@@ -35,42 +35,37 @@ This approach is avaliable for the following ad formats:
 * Video Interstitial via `VideoInterstitialAdUnit`
 * Rewarded Video via `RewardedVideoAdUnit`
 * Native Styles via `NativeRequest`
+* Multiformat ad unit via `PrebidAdUnit`
 
 The basic integration steps for these ad units you can find at the page for integration using [Original API](/prebid-mobile/pbm-api/ios/ios-sdk-integration-gam-original-api.html). The diference is that you should use  the `fetchDemand` function with following signature:
 
-```swift
-dynamic public func fetchDemand(
-        completion: @escaping(_ result: ResultCode,
-                              _ kvResultDict: [String : String]?) -> Void)
+``` swift
+public func fetchDemand(adObject: AnyObject, request: PrebidRequest,
+                      completion: @escaping (BidInfo) -> Void)
 ```
 
 Examples:
 
-```swift
-func loadBanner() {
-    
-    //adUnit is BannerAdUnit type
-    adUnit.fetchDemand { [weak self] (resultCode: ResultCode, targetingDict: [String : String]?) in
-        
-        self?.adServerRequest.customTargeting = targetingDict
-        self?.adServerBanner.load(self?.adServerRequest)
-    }
-}
+``` swift
+adUnit.fetchDemand(adObject: gamRequest, request: prebidRequest) { [weak self] bidInfo in
+    guard let self = self else { return }
 
-func loadRewardedVideo() {
-    let adUnit = RewardedVideoAdUnit(configId: "1001-1")
-    adUnit.fetchDemand { [weak self] (resultCode: ResultCode, targetingDict: [String : String]?) in
-        
         //Publisher should provide support for converting keys into format of 3rd party ad server and loading ads
-        let keywords = convertDictToAdServerKeywords(dict: targetingDict)
-        AdServerLoadAds.loadAd(withAdUnitID: "46d2ebb3ccd340b38580b5d3581c6434", keywords: keywords)
-    }
+    let keywords = convertDictToAdServerKeywords(dict: bidInfo.targetingKeywords)
+    AdServerLoadAds.loadAd(withAdUnitID: "46d2ebb3ccd340b38580b5d3581c6434", keywords: keywords)
 }
 ```
 
+The `BidInfo` provides the following properties:
+
+* `resultCode` - the object of type `ResultCode` describing the status of the bid request.
+* `targetingKeywords` - the targeting keywords of the winning bid
+* `exp` - the number of seconds that may elapse between the auction and the actual impression. In this case, it indicates the approximate TTL of the bid in the Prebid Cache. Note that the actual expiration time of the bid will be less than this number due to the network and operational overhead. The Prebid SDK doesn't make any adjustments to this value.
+* `nativeAdCacheId` - the local cache ID of the winning bid. Applied only to the `native` ad format.
+
 ## Rendering API
 
-The Rendering API integration and usage are similar to any other Ad SDK. In this case, Prebid SDK sends the bid requests to the Prebid Server and renders the winning bid. 
+The Rendering API integration and usage are similar to any other Ad SDK. In this case, Prebid SDK sends the bid requests to the Prebid Server and renders the winning bid.
 
 ![In-App Bidding with Prebid](/assets/images/prebid-mobile/modules/rendering/Prebid-In-App-Bidding-Overview-Pure-Prebid.png)
 
@@ -78,14 +73,14 @@ The Rendering API integration and usage are similar to any other Ad SDK. In this
 
 Integration example:
 
-```swift
+``` swift
 // 1. Create an Ad View
 let banner = BannerView(frame: CGRect(origin: .zero, size: adSize),
                         configID: CONFIG_ID,
                         adSize: adSize)
-    
+
 banner.delegate = self
-    
+
 // 2. Load an Ad
 banner.loadAd()
 ```
@@ -95,24 +90,24 @@ banner.loadAd()
 
 Initialize the `BannerAdView` with properties:
 
-- `frame` - the frame rectangle for the view
-- `configID` - an ID of the Stored Impression on the Prebid Server
-- `size` - the size of the ad unit which will be used in the bid request.
+* `frame` - the frame rectangle for the view
+* `configID` - an ID of the Stored Impression on the Prebid Server
+* `size` - the size of the ad unit which will be used in the bid request.
 
 #### Step 2: Load the Ad
 {:.no_toc}
 
 Call the method `loadAd()` which will:
 
-- make a bid request to the Prebid Server.
-- render the winning bid on display.
+* make a bid request to the Prebid Server.
+* render the winning bid on display.
 
 #### Outstream Video
 {:.no_toc}
 
 For **Banner Video** you also need to specify the ad format:
 
-```swift
+``` swift
 banner.adFormat = .video
 ```
 
@@ -120,13 +115,13 @@ banner.adFormat = .video
 
 Integration example:
 
-```swift
+``` swift
 // 1. Create an Interstitial Ad Unit
 interstitial = InterstitialRenderingAdUnit(configID: CONFIG_ID,
                                   minSizePercentage: CGSize(width: 30, height: 30))
-    
+
 interstitial.delegate = self
-    
+
 // 2. Load an Ad
 interstitial.loadAd()
 
@@ -141,14 +136,14 @@ if interstitial.isReady {
 
 The **default** ad format for interstitial is **.banner**. In order to make a `multiformat bid request`, set the respective values into the `adFormats` property.
 
-```swift
-// Make bid request for video ad                                     
+``` swift
+// Make bid request for video ad
 adUnit?.adFormats = [.video]
 
-// Make bid request for both video and banner ads                                     
+// Make bid request for both video and banner ads
 adUnit?.adFormats = [.video, .banner]
 
-// Make bid request for banner ad (default behaviour)                                     
+// Make bid request for banner ad (default behaviour)
 adUnit?.adFormats = [.banner]
 
 ```
@@ -157,9 +152,9 @@ adUnit?.adFormats = [.banner]
 {:.no_toc}
 
 Initialize the Interstitial Ad Unit with properties:
-    
-- `configID` - an ID of Stored Impression on the Prebid Server
-- `minSizePercentage` - specifies the minimum width and height percent an ad may occupy of a device’s real estate.
+
+* `configID` - an ID of Stored Impression on the Prebid Server
+* `minSizePercentage` - specifies the minimum width and height percent an ad may occupy of a device’s real estate.
 
 > **NOTE:** minSizePercentage - plays an important role in a bidding process for banner ads. If provided space is not enough demand partners won't respond with the bids.
 
@@ -173,9 +168,9 @@ Call the method `loadAd()` which will make a bid request to Prebid server.
 
 Wait until the ad will be loaded and present it to the user in any suitable time.
 
-```swift
+``` swift
 // MARK: InterstitialRenderingAdUnitDelegate
-    
+
 func interstitialDidReceiveAd(_ interstitial: InterstitialRenderingAdUnit) {
     // Now the ad is ready for display
 }
@@ -185,11 +180,11 @@ func interstitialDidReceiveAd(_ interstitial: InterstitialRenderingAdUnit) {
 
 Integration example:
 
-```swift
+``` swift
 // 1. Create an Ad Unit
 rewardedAd = RewardedAdUnit(configID: CONFIG_ID)
 rewardedAd.delegate = self
-    
+
 // 2. Load an Ad
 rewardedAd.loadAd()
 
@@ -201,13 +196,12 @@ if rewardedAd.isReady {
 }
 ```
 
-
 #### Step 1: Create Rewarded Ad Unit
 {:.no_toc}
 
 Create the `RewardedAdUnit` object with parameter:
 
-- `configID` - an ID of Stored Impression on the Prebid Server
+* `configID` - an ID of Stored Impression on the Prebid Server
 
 #### Step 2: Load the Ad
 {:.no_toc}
@@ -219,10 +213,10 @@ Call the `loadAd()` method which will make a bid request to Prebid server.
 
 Wait until the ad will be loaded and present it to the user in any suitable time.
 
-```swift
+``` swift
 // MARK: RewardedAdUnitDelegate
-    
+
 func rewardedAdDidReceiveAd(_ rewardedAd: RewardedAdUnit) {
     // Now the ad is ready for display
-}   
+}
 ```
diff --git a/prebid-mobile/pbm-api/android/android-sdk-integration-gam-original-api.md b/prebid-mobile/pbm-api/android/android-sdk-integration-gam-original-api.md
index b8f2909ca4..3e7559b162 100755
--- a/prebid-mobile/pbm-api/android/android-sdk-integration-gam-original-api.md
+++ b/prebid-mobile/pbm-api/android/android-sdk-integration-gam-original-api.md
@@ -1120,6 +1120,305 @@ Without it the SDK won't be able to recognize the Prebid line item.
 
 Once the Prebid line item is recognized you should extract the ad from the winning bid and init the view properties with native assets data.
 
+## Multiformat API
+
+Starting with version `2.1.5` Prebid SDK supports the fully multiformat ad unit. It allows to run bid requests with any combination of `banner`, `video`, and `native` formats.
+
+The following code demonstrates the integration of multiformat ad unit.
+
+``` kotlin
+private fun createAd() {
+    // random() only for test cases, in production use only one config id
+    val configId = listOf(CONFIG_ID_BANNER, CONFIG_ID_VIDEO, CONFIG_ID_NATIVE).random()
+
+    // Step 1: Create a PrebidAdUnit
+    prebidAdUnit = PrebidAdUnit(configId)
+
+    // Step 2: Create PrebidRequest
+    val prebidRequest = PrebidRequest()
+
+    // Step 3: Setup the parameters
+    prebidRequest.setBannerParameters(createBannerParameters())
+    prebidRequest.setVideoParameters(createVideoParameters())
+    prebidRequest.setNativeParameters(createNativeParameters())
+
+    // Step 4: Make a bid request
+    val gamRequest = AdManagerAdRequest.Builder().build()
+    prebidAdUnit?.fetchDemand(prebidRequest, gamRequest) {
+        // Step 5: Load an Ad
+
+        loadGam(gamRequest)
+    }
+}
+
+private fun createBannerParameters(): BannerParameters {
+    val parameters = BannerParameters()
+    parameters.api = listOf(Signals.Api.MRAID_3, Signals.Api.OMID_1)
+
+    return parameters
+}
+
+private fun createVideoParameters(): VideoParameters {
+    return VideoParameters(listOf("video/mp4"))
+}
+
+private fun createNativeParameters(): NativeParameters {
+    val assets = mutableListOf<NativeAsset>()
+
+    val title = NativeTitleAsset()
+    title.setLength(90)
+    title.isRequired = true
+    assets.add(title)
+
+    val icon = NativeImageAsset(20, 20, 20, 20)
+    icon.imageType = NativeImageAsset.IMAGE_TYPE.ICON
+    icon.isRequired = true
+    assets.add(icon)
+
+    val image = NativeImageAsset(200, 200, 200, 200)
+    image.imageType = NativeImageAsset.IMAGE_TYPE.MAIN
+    image.isRequired = true
+    assets.add(image)
+
+    val data = NativeDataAsset()
+    data.len = 90
+    data.dataType = NativeDataAsset.DATA_TYPE.SPONSORED
+    data.isRequired = true
+    assets.add(data)
+
+    val body = NativeDataAsset()
+    body.isRequired = true
+    body.dataType = NativeDataAsset.DATA_TYPE.DESC
+    assets.add(body)
+
+    val cta = NativeDataAsset()
+    cta.isRequired = true
+    cta.dataType = NativeDataAsset.DATA_TYPE.CTATEXT
+    assets.add(cta)
+
+    val nativeParameters = NativeParameters(assets)
+    nativeParameters.addEventTracker(
+        NativeEventTracker(
+            NativeEventTracker.EVENT_TYPE.IMPRESSION,
+            arrayListOf(NativeEventTracker.EVENT_TRACKING_METHOD.IMAGE)
+        )
+    )
+    nativeParameters.setContextType(NativeAdUnit.CONTEXT_TYPE.SOCIAL_CENTRIC)
+    nativeParameters.setPlacementType(NativeAdUnit.PLACEMENTTYPE.CONTENT_FEED)
+    nativeParameters.setContextSubType(NativeAdUnit.CONTEXTSUBTYPE.GENERAL_SOCIAL)
+
+    return nativeParameters
+}
+```
+
+If you use Custom Native Ads follow the [guide](https://developers.google.com/ad-manager/mobile-ads-sdk/ios/native-banner) on how to implement processing of the ad response of the respective type. The following code snipet demonstrates how you can process the banner, video and in-banner native (Native Styles) ad resposnse:
+
+``` kotlin
+private fun loadGam(gamRequest: AdManagerAdRequest) {
+    val onBannerLoaded = OnAdManagerAdViewLoadedListener { adView ->
+        showBannerAd(adView)
+    }
+
+    val onNativeLoaded = OnNativeAdLoadedListener { nativeAd ->
+        showNativeAd(nativeAd, adWrapperView)
+    }
+
+    val onPrebidNativeAdLoaded = OnCustomFormatAdLoadedListener { customNativeAd ->
+        showPrebidNativeAd(customNativeAd)
+    }
+
+    // Prepare the lisners for multiformat Ad Response
+    val adLoader = AdLoader.Builder(this, AD_UNIT_ID)
+        .forAdManagerAdView(onBannerLoaded, AdSize.BANNER, AdSize.MEDIUM_RECTANGLE)
+        .forNativeAd(onNativeLoaded)
+        .forCustomFormatAd(CUSTOM_FORMAT_ID, onPrebidNativeAdLoaded, null)
+        .withAdListener(AdListenerWithToast(this))
+        .withAdManagerAdViewOptions(AdManagerAdViewOptions.Builder().build())
+        .build()
+
+    adLoader.loadAd(gamRequest)
+}
+```
+
+The methods managing the prebid and GAM ads:
+
+``` kotlin
+private fun showBannerAd(adView: AdManagerAdView) {
+    adWrapperView.addView(adView)
+    AdViewUtils.findPrebidCreativeSize(adView, object : AdViewUtils.PbFindSizeListener {
+        override fun success(width: Int, height: Int) {
+            adView.setAdSizes(AdSize(width, height))
+        }
+
+        override fun failure(error: PbFindSizeError) {}
+    })
+}
+
+private fun showNativeAd(ad: NativeAd, wrapper: ViewGroup) {
+    val nativeContainer = View.inflate(wrapper.context, R.layout.layout_native, null)
+
+    val icon = nativeContainer.findViewById<ImageView>(R.id.imgIcon)
+    val iconUrl = ad.icon?.uri?.toString()
+    if (iconUrl != null) {
+        ImageUtils.download(iconUrl, icon)
+    }
+
+    val title = nativeContainer.findViewById<TextView>(R.id.tvTitle)
+    title.text = ad.headline
+
+    val image = nativeContainer.findViewById<ImageView>(R.id.imgImage)
+    val imageUrl = ad.images.getOrNull(0)?.uri?.toString()
+    if (imageUrl != null) {
+        ImageUtils.download(imageUrl, image)
+    }
+
+    val description = nativeContainer.findViewById<TextView>(R.id.tvDesc)
+    description.text = ad.body
+
+    val cta = nativeContainer.findViewById<Button>(R.id.btnCta)
+    cta.text = ad.callToAction
+
+    wrapper.addView(nativeContainer)
+}
+
+private fun showPrebidNativeAd(customNativeAd: NativeCustomFormatAd) {
+    AdViewUtils.findNative(customNativeAd, object : PrebidNativeAdListener {
+        override fun onPrebidNativeLoaded(ad: PrebidNativeAd) {
+            inflatePrebidNativeAd(ad)
+        }
+
+        override fun onPrebidNativeNotFound() {
+            Log.e("PrebidAdViewUtils", "Find native failed: native not found")
+        }
+
+        override fun onPrebidNativeNotValid() {
+            Log.e("PrebidAdViewUtils", "Find native failed: native not valid")
+        }
+    })
+}
+
+private fun inflatePrebidNativeAd(ad: PrebidNativeAd) {
+    val nativeContainer = View.inflate(this, R.layout.layout_native, null)
+
+    val icon = nativeContainer.findViewById<ImageView>(R.id.imgIcon)
+    ImageUtils.download(ad.iconUrl, icon)
+
+    val title = nativeContainer.findViewById<TextView>(R.id.tvTitle)
+    title.text = ad.title
+
+    val image = nativeContainer.findViewById<ImageView>(R.id.imgImage)
+    ImageUtils.download(ad.imageUrl, image)
+
+    val description = nativeContainer.findViewById<TextView>(R.id.tvDesc)
+    description.text = ad.description
+
+    val cta = nativeContainer.findViewById<Button>(R.id.btnCta)
+    cta.text = ad.callToAction
+
+    ad.registerView(nativeContainer, Lists.newArrayList(icon, title, image, description, cta), null)
+
+    adWrapperView.addView(nativeContainer)
+}
+```
+
+### Step 1: Create a PrebidAdUnit
+{:.no_toc}
+
+Initialize the `PrebidAdUnit` with the following properties:
+
+* `configId` - an ID of the Stored Impression on the Prebid Server
+
+### Step 2: Create a PrebidRequest
+{:.no_toc}
+
+Create the instance of `PrebidRequest` initializing it with respective ad format parameters.
+
+In addition you can set the following properties of the `PrebidRequest`.
+
+### Step 3: Setup the parameters
+{:.no_toc}
+
+For each intersted ad format you should creatae a respective configuration parameter:
+
+* [BannerParameters](#step-2-configure-banner-parameters) object.
+* [VideoParameters](#step-2-configure-the-video-parameters) object.
+* [NativeParameters](#nativeparameters) object
+
+#### NativeParameters
+{:.no_toc}
+
+Using the `NativeParameters` you can customize the bid request for video ads.
+
+##### assets
+{:.no_toc}
+
+The array of requested asset objects. Prebid SDK supports all kinds of assets according to the [IAB spec](https://iabtechlab.com/wp-content/uploads/2016/07/OpenRTB-Native-Ads-Specification-Final-1.2.pdf)  except `video`.
+
+##### eventtrackers
+{:.no_toc}
+
+The array of requested native trackers. Prebid SDK supports inly `image` trackers according to the [IAB spec](https://iabtechlab.com/wp-content/uploads/2016/07/OpenRTB-Native-Ads-Specification-Final-1.2.pdf).
+
+##### version
+{:.no_toc}
+
+Version of the Native Markup version in use. The default value is `1.2`
+
+##### context
+{:.no_toc}
+
+The context in which the ad appears.
+
+##### contextSubType
+{:.no_toc}
+
+A more detailed context in which the ad appears.
+
+##### placementType
+{:.no_toc}
+
+The design/format/layout of the ad unit being offered.
+
+##### placementCount
+{:.no_toc}
+
+The number of identical placements in this Layout.
+
+##### sequence
+{:.no_toc}
+
+0 for the first ad, 1 for the second ad, and so on.
+
+##### asseturlsupport
+{:.no_toc}
+
+Whether the supply source/impression supports returning an assetsurl instead of an asset object. 0 or the absence of the field indicates no such support.
+
+##### durlsupport
+{:.no_toc}
+
+Whether the supply source / impression supports returning a dco url instead of an asset object. 0 or the absence of the field indicates no such support.
+
+##### privacy
+{:.no_toc}
+
+Set to 1 when the native ad supports buyer-specific privacy notice.  Set to 0 (or field absent) when the native ad doesn’t support custom privacy links or if support is unknown.
+
+##### ext
+{:.no_toc}
+
+This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification
+
+### Step 4: Make a bid request
+{:.no_toc}
+
+The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests.
+
+### Step 5: Load and Ad
+{:.no_toc}
+
+Follow the [GMA SDK documentation](https://developers.google.com/ad-manager/mobile-ads-sdk/android/native-banner) to combine the a banner and custom native ads int the app.
+
 ## Ad Unit Configuration
 
 Each ad unit in the Original API is a subclass of the `AdUnit` class, which provides the following properties and methods for additional configuration.
diff --git a/prebid-mobile/pbm-api/ios/ios-sdk-integration-gam-original-api.md b/prebid-mobile/pbm-api/ios/ios-sdk-integration-gam-original-api.md
index f994255fb9..e523317970 100644
--- a/prebid-mobile/pbm-api/ios/ios-sdk-integration-gam-original-api.md
+++ b/prebid-mobile/pbm-api/ios/ios-sdk-integration-gam-original-api.md
@@ -10,14 +10,14 @@ sidebarType: 2
 # Prebid Mobile with GAM (Original API)
 {:.no_toc}
 
-Prebid Mobile is an open-source library that provides an end-to-end header bidding solution for mobile app publishers. 
+Prebid Mobile is an open-source library that provides an end-to-end header bidding solution for mobile app publishers.
 
 * TOC
 {:toc}
 
 ## Overview
 
-This is the original Prebid mobile integration approach when SDK plays the transport role and the winning bid is rendered by the primary ad server SDK using PUC. You can find details of how it works and other integration approaches on the [overview page](/prebid-mobile/prebid-mobile.html#with-ad-server-original-api).  
+This is the original Prebid mobile integration approach when SDK plays the transport role and the winning bid is rendered by the primary ad server SDK using PUC. You can find details of how it works and other integration approaches on the [overview page](/prebid-mobile/prebid-mobile.html#with-ad-server-original-api).
 
 ![In-App Bidding with Prebid](/assets/images/prebid-mobile/prebid-in-app-bidding-overview-prebid-original-gam.png)
 
@@ -29,8 +29,8 @@ Starting with Prebid Mobile `2.1.0` you can use `BannerAdUnit` to bid over the b
 
 Integration example:
 
-```swift
-// 1. Create a BannerAdUnit 
+``` swift
+// 1. Create a BannerAdUnit
 adUnit = BannerAdUnit(configId: CONFIG_ID, size: adSize)
 adUnit.setAutoRefreshMillis(time: 30000)
 
@@ -52,15 +52,15 @@ bannerView?.addSubview(gamBanner)
 let gamRequest = GAMRequest()
 adUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
     PrebidDemoLogger.shared.info("Prebid demand fetch for GAM \(resultCode.name())")
-    
+
     // 5. Load GAM Ad
     self?.gamBanner.load(gamRequest)
 }
 ```
 
-Implement GADBannerViewDelegate: 
+Implement GADBannerViewDelegate:
 
-```swift
+``` swift
 func bannerViewDidReceiveAd(_ bannerView: GADBannerView) {
 
     // 6. Resize ad view if needed
@@ -78,15 +78,15 @@ func bannerViewDidReceiveAd(_ bannerView: GADBannerView) {
 
 Initialize the `BannerAdUnit` with the following properties:
 
-- `configId` - an ID of the Stored Impression on the Prebid Server
-- `adSize` - the size of the ad unit which will be used in the bid request.
+* `configId` - an ID of the Stored Impression on the Prebid Server
+* `adSize` - the size of the ad unit which will be used in the bid request.
 
 #### Step 2: Configure banner parameters
 {:.no_toc}
 
-Using the `BannerParameters` you can customize the bid request for the BannerAdUnit. 
+Using the `BannerParameters` you can customize the bid request for the BannerAdUnit.
 
-The `api` property is dedicated to adding values for API Frameworks to bid response according to the OpenRTB 2.5](https://www.iab.com/wp-content/uploads/2016/03/OpenRTB-API-Specification-Version-2-5-FINAL.pdf) spec. The supported values for GMA SDK integration are:
+The `api` property is dedicated to adding values for API Frameworks to bid response according to the OpenRTB [2.5](https://www.iab.com/wp-content/uploads/2016/03/OpenRTB-API-Specification-Version-2-5-FINAL.pdf) spec. The supported values for GMA SDK integration are:
 
 * `3` or `Signals.Api.MRAID_1` : MRAID-1 support signal
 * `5` or `Signals.Api.MRAID_2` : MRAID-2 support signal
@@ -99,88 +99,88 @@ Starting from PrebidMobile `2.1.0` the `parameters` property is deprecated. Use
 #### Step 3: Create a GAMBannerView
 {:.no_toc}
 
-Follow the [GMA SDK documentation](https://developers.google.com/ad-manager/mobile-ads-sdk/ios/banner) to integrate a banner ad unit. 
+Follow the [GMA SDK documentation](https://developers.google.com/ad-manager/mobile-ads-sdk/ios/banner) to integrate a banner ad unit.
 
 #### Step 4: Make a bid request
 {:.no_toc}
 
-The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests. 
+The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests.
 
 #### Step 5: Load an Ad
 {:.no_toc}
 
-Now you should request the ad from GAM. If the `GAMRequest` contains targeting keywords, the respective Prebid line item will be returned from GAM and GMA SDK will render its creative. 
+Now you should request the ad from GAM. If the `GAMRequest` contains targeting keywords, the respective Prebid line item will be returned from GAM and GMA SDK will render its creative.
 
 Be sure that you make the ad request with the same `GAMRequest` object that you passed to the `fetchDemand` method. Otherwise, the ad request won't contain targeting keywords, and Prebid's ad won't ever be displayed.
 
 #### Step 6: Adjust the ad view size
 {:.no_toc}
 
-Once an app receives a signal that an ad is loaded, you should use the method `AdViewUtils.findPrebidCreativeSize` to verify whether it is a Prebid ad and resize the ad slot respectively to the creative's properties. 
+Once an app receives a signal that an ad is loaded, you should use the method `AdViewUtils.findPrebidCreativeSize` to verify whether it is a Prebid ad and resize the ad slot respectively to the creative's properties.
 
 ### Video Banner (Outstream Video)
 
 Integration example:
 
-```swift
+``` swift
 // 1. Create a BannerAdUnit
 adUnit = BannerAdUnit(configId: CONFIG_ID, size: adSize)
 
 // 2. Set ad format
 adUnit.adFormats = [.video]
-    
+
 // 3. Configure video parameters
 let parameters = VideoParameters(mimes: ["video/mp4"])
 parameters.protocols = [Signals.Protocols.VAST_2_0]
 parameters.playbackMethod = [Signals.PlaybackMethod.AutoPlaySoundOff]
 parameters.placement = Signals.Placement.InBanner
 adUnit.videoParameters = parameters
-    
+
 // 4. Create a GAMBannerView
 gamBanner = GAMBannerView(adSize: GADAdSizeFromCGSize(adSize))
 gamBanner.adUnitID = gamAdUnitVideoBannerOriginal
 gamBanner.rootViewController = self
 gamBanner.delegate = self
-    
+
 // Add GMA SDK banner view to the app UI
 bannerView.addSubview(gamBanner)
 bannerView.backgroundColor = .clear
-    
+
 // 5. Make a bid request to Prebid Server
 let gamRequest = GAMRequest()
 adUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
     PrebidDemoLogger.shared.info("Prebid demand fetch for GAM \(resultCode.name())")
-        
+
     // 6. Load GAM Ad
     self?.gamBanner.load(gamRequest)
 }
 ```
 
 {: .alert.alert-warning :}
-Starting from PrebidMobile `2.1.0` the `VideoAdUnit` class is deprecated. Use `BannerAdUnit` class with video ad format instead. 
+Starting from PrebidMobile `2.1.0` the `VideoAdUnit` class is deprecated. Use `BannerAdUnit` class with video ad format instead.
 
 #### Step 1: Create a BannerAdUnit
 {:.no_toc}
 
 Initialize the `BannerAdUnit` with the following properties:
 
-- `configId` - an ID of the Stored Impression on the Prebid Server
-- `adSize` - the size of the ad unit which will be used in the bid request.
+* `configId` - an ID of the Stored Impression on the Prebid Server
+* `adSize` - the size of the ad unit which will be used in the bid request.
 
 #### Step 2: Set ad format
 {:.no_toc}
 
-For video ad unit, you must set video ad format. Default value for `adFormats` property is `[.banner]`.  
+For video ad unit, you must set video ad format. Default value for `adFormats` property is `[.banner]`.
 
 #### Step 3: Configure the video parameters
 {:.no_toc}
 
-Using the `VideoParameters` you can customize the bid request for video ads. 
+Using the `VideoParameters` you can customize the bid request for video ads.
 
 #### placement
 {:.no_toc}
 
-[OpenRTB 2.5](https://www.iab.com/wp-content/uploads/2016/03/OpenRTB-API-Specification-Version-2-5-FINAL.pdf) Placement Type for the auction can be expressed as an integer array or you can use an enum for easier readability. Option 1 (in-stream) is intentionally left out due to lack of in-stream support in Prebid SDK. 
+[OpenRTB 2.5](https://www.iab.com/wp-content/uploads/2016/03/OpenRTB-API-Specification-Version-2-5-FINAL.pdf) Placement Type for the auction can be expressed as an integer array or you can use an enum for easier readability. Option 1 (in-stream) is intentionally left out due to lack of in-stream support in Prebid SDK.
 
 In the context of a VideoInterstitialAdUnit, rewarded video ads are typically labeled as interstitial. As such, Prebid SDK will default to value 5 if no placement value is supplied.
 
@@ -192,10 +192,10 @@ In the context of a VideoInterstitialAdUnit, rewarded video ads are typically la
 #### api
 {:.no_toc}
 
-The `api` property is dedicated to adding values for API Frameworks to bid response according to the OpenRTB 2.5](https://www.iab.com/wp-content/uploads/2016/03/OpenRTB-API-Specification-Version-2-5-FINAL.pdf) spec. The supported values for GMA SDK integration are:
+The `api` property is dedicated to adding values for API Frameworks to bid response according to the [OpenRTB 2.5](https://www.iab.com/wp-content/uploads/2016/03/OpenRTB-API-Specification-Version-2-5-FINAL.pdf) spec. The supported values for GMA SDK integration are:
 
-* `1` or `Signals.Api.VPAID_1` : VPAID 1.0  
-* `2` or `Signals.Api.VPAID_2` : VPAID 2.0  
+* `1` or `Signals.Api.VPAID_1` : VPAID 1.0
+* `2` or `Signals.Api.VPAID_2` : VPAID 2.0
 * `3` or `Signals.Api.MRAID_1` : MRAID-1 support signal
 * `5` or `Signals.Api.MRAID_2` : MRAID-2 support signal
 * `6` or `Signals.Api.MRAID_3` : MRAID-3 support signal
@@ -231,42 +231,42 @@ Required property.
 {:.no_toc}
 
 Array of OpenRTB 2.5 playback methods. If none are specified, any method may be used. Only one method is typically used in practice. It is strongly advised to use only the first element of the array.
-  
-  - `1` or `Signals.PlaybackMethod.AutoPlaySoundOn` : Initiates on Page Load with Sound On
-  - `2` or `Signals.PlaybackMethod.AutoPlaySoundOff` : Initiates on Page Load with Sound Off by Default
-  - `3` or `Signals.PlaybackMethod.ClickToPlay` : Initiates on Click with Sound On
-  - `4` or `Signals.PlaybackMethod.MouseOver` : Initiates on Mouse-Over with Sound On
-  - `5` or `Signals.PlaybackMethod.EnterSoundOn` : Initiates on Entering Viewport with Sound On
-  - `6` or `Signals.PlaybackMethod.EnterSoundOff`: Initiates on Entering Viewport with Sound Off by Default
+
+* `1` or `Signals.PlaybackMethod.AutoPlaySoundOn` : Initiates on Page Load with Sound On
+* `2` or `Signals.PlaybackMethod.AutoPlaySoundOff` : Initiates on Page Load with Sound Off by Default
+* `3` or `Signals.PlaybackMethod.ClickToPlay` : Initiates on Click with Sound On
+* `4` or `Signals.PlaybackMethod.MouseOver` : Initiates on Mouse-Over with Sound On
+* `5` or `Signals.PlaybackMethod.EnterSoundOn` : Initiates on Entering Viewport with Sound On
+* `6` or `Signals.PlaybackMethod.EnterSoundOff`: Initiates on Entering Viewport with Sound Off by Default
 
 #### protocols
 {:.no_toc}
 
   Array or enum of OpenRTB 2.5 supported Protocols. Values can be one of:
-  
-  - `1` or `Signals.Protocols.VAST_1_0` : VAST 1.0
-  - `2` or `Signals.Protocols.VAST_2_0` : VAST 2.0
-  - `3` or `Signals.Protocols.VAST_3_0` : VAST 3.0
-  - `4` or `Signals.Protocols.VAST_1_0_Wrapper` : VAST 1.0 Wrapper
-  - `5` or `Signals.Protocols.VAST_2_0_Wrapper` : VAST 2.0 Wrapper
-  - `6` or `Signals.Protocols.VAST_3_0_Wrapper` : VAST 3.0 Wrapper
-  - `7` or `Signals.Protocols.VAST_4_0` : VAST 4.0
-  - `8` or `Signals.Protocols.VAST_4_0_Wrapper` : VAST 4.0 Wrapper
+
+* `1` or `Signals.Protocols.VAST_1_0` : VAST 1.0
+* `2` or `Signals.Protocols.VAST_2_0` : VAST 2.0
+* `3` or `Signals.Protocols.VAST_3_0` : VAST 3.0
+* `4` or `Signals.Protocols.VAST_1_0_Wrapper` : VAST 1.0 Wrapper
+* `5` or `Signals.Protocols.VAST_2_0_Wrapper` : VAST 2.0 Wrapper
+* `6` or `Signals.Protocols.VAST_3_0_Wrapper` : VAST 3.0 Wrapper
+* `7` or `Signals.Protocols.VAST_4_0` : VAST 4.0
+* `8` or `Signals.Protocols.VAST_4_0_Wrapper` : VAST 4.0 Wrapper
 
 #### Step 4: Create a GAMBannerView
 {:.no_toc}
 
-Follow the [GMA SDK documentation](https://developers.google.com/ad-manager/mobile-ads-sdk/ios/banner) to integrate a banner ad unit. 
+Follow the [GMA SDK documentation](https://developers.google.com/ad-manager/mobile-ads-sdk/ios/banner) to integrate a banner ad unit.
 
 #### Step 5: Make a bid request
 {:.no_toc}
 
-The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests. 
+The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests.
 
 #### Step 6: Load an Ad
 {:.no_toc}
 
-You should now request the ad from GAM. If the `GAMRequest` contains targeting keywords. The respective Prebid line item will be returned from GAM and GMA SDK will render its creative. 
+You should now request the ad from GAM. If the `GAMRequest` contains targeting keywords. The respective Prebid line item will be returned from GAM and GMA SDK will render its creative.
 
 Be sure that you make the ad request with the same `GAMRequest` object that you passed to the `fetchDemand` method. Otherwise the ad request won't contain targeting keywords and Prebid's ad won't ever be displayed.
 
@@ -274,7 +274,7 @@ Be sure that you make the ad request with the same `GAMRequest` object that you
 
 Integration example:
 
-```swift
+``` swift
 // 1. Create a BannerAdUnit
 adUnit = BannerAdUnit(configId: CONFIG_ID, size: adSize)
 adUnit.setAutoRefreshMillis(time: 30000)
@@ -307,15 +307,15 @@ bannerView?.addSubview(gamBanner)
 let gamRequest = GAMRequest()
 adUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
     PrebidDemoLogger.shared.info("Prebid demand fetch for GAM \(resultCode.name())")
-    
+
     // 7. Load GAM Ad
     self?.gamBanner.load(gamRequest)
 }
 ```
 
-Implement GADBannerViewDelegate: 
+Implement GADBannerViewDelegate:
 
-```swift
+``` swift
 func bannerViewDidReceiveAd(_ bannerView: GADBannerView) {
 
     // 8. Resize ad view if needed
@@ -333,13 +333,13 @@ func bannerViewDidReceiveAd(_ bannerView: GADBannerView) {
 
 Initialize the `BannerAdUnit` with the following properties:
 
-- `configId` - an ID of the Stored Impression on the Prebid Server
-- `adSize` - the size of the ad unit which will be used in the bid request.
+* `configId` - an ID of the Stored Impression on the Prebid Server
+* `adSize` - the size of the ad unit which will be used in the bid request.
 
 #### Step 2: Set ad formats
 {:.no_toc}
 
-For multiformat ad unit, you must set both banner and video ad formats. 
+For multiformat ad unit, you must set both banner and video ad formats.
 
 #### Step 3: Configure banner parameters
 {:.no_toc}
@@ -354,42 +354,42 @@ Provide configuration properties for the video ad using the [VideoParameters](#s
 #### Step 5: Create a GAMBannerView
 {:.no_toc}
 
-Follow the [GMA SDK documentation](https://developers.google.com/ad-manager/mobile-ads-sdk/ios/banner) to integrate a banner ad unit. 
+Follow the [GMA SDK documentation](https://developers.google.com/ad-manager/mobile-ads-sdk/ios/banner) to integrate a banner ad unit.
 
 #### Step 6: Make a bid request
 {:.no_toc}
 
-The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests. 
+The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests.
 
 #### Step 7: Load an Ad
 {:.no_toc}
 
-Now you should request the ad from GAM. If the `GAMRequest` contains targeting keywords, the respective Prebid line item will be returned from GAM and GMA SDK will render its creative. 
+Now you should request the ad from GAM. If the `GAMRequest` contains targeting keywords, the respective Prebid line item will be returned from GAM and GMA SDK will render its creative.
 
 Be sure that you make the ad request with the same `GAMRequest` object that you passed to the `fetchDemand` method. Otherwise, the ad request won't contain targeting keywords, and Prebid's ad won't ever be displayed.
 
 #### Step 8: Adjust the ad view size
 {:.no_toc}
 
-Once an app receives a signal that an ad is loaded, you should use the method `AdViewUtils.findPrebidCreativeSize` to verify whether it is a Prebid ad and resize the ad slot respectively to the creative's properties. 
+Once an app receives a signal that an ad is loaded, you should use the method `AdViewUtils.findPrebidCreativeSize` to verify whether it is a Prebid ad and resize the ad slot respectively to the creative's properties.
 
 ## Interstitial API
 
-Starting with Prebid Mobile `2.1.0` you can use `InterstitialAdUnit ` to bid over the banner and/or video demand. The default ad format is `.banner`. To customize the bidding format you should specify the `adFormats` property of the `InterstitialAdUnit `.
+Starting with Prebid Mobile `2.1.0` you can use `InterstitialAdUnit` to bid over the banner and/or video demand. The default ad format is `.banner`. To customize the bidding format you should specify the `adFormats` property of the `InterstitialAdUnit`.
 
 ### HTML Interstitial
 
 Integration example:
 
-```swift
+``` swift
 // 1. Create an Interstitial Ad Unit
 adUnit = InterstitialAdUnit(configId: CONFIG_ID)
 
-// 2. Make a bid request to Prebid Server 
+// 2. Make a bid request to Prebid Server
 let gamRequest = GAMRequest()
 adUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
     PrebidDemoLogger.shared.info("Prebid demand fetch for GAM \(resultCode.name())")
-    
+
     // 3. Load a GAM interstitial ad
     GAMInterstitialAd.load(withAdManagerAdUnitID: gamAdUnitDisplayInterstitialOriginal, request: gamRequest) { ad, error in
         guard let self = self else { return }
@@ -397,7 +397,7 @@ adUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
             PrebidDemoLogger.shared.error("Failed to load interstitial ad with error: \(error.localizedDescription)")
         } else if let ad = ad {
             ad.fullScreenContentDelegate = self
-            
+
             // 4. Present the interstitial ad
             ad.present(fromRootViewController: self)
         }
@@ -409,15 +409,15 @@ adUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
 {:.no_toc}
 
 Initialize the InterstitialAdUnit with the following properties:
-    
-- `configId` - an ID of Stored Impression on the Prebid Server
-- `minWidthPerc`: Optional parameter to specify the minimum width percent an ad may occupy of a device's real estate. Support in SDK version 1.2+
-- `minHeightPrec`: Optional parameter to specify the minimum height percent an ad may occupy of a device's real estate. Support in SDK version 1.2+
 
-> **NOTE:** As of version 1.2+, Prebid SDK has extended the functionality of Interstitial ad monetization by using a smart ad size selection process to monetize sizes smaller than full screen ads. App developers can specify a minimum width and minimum height percentage an ad can occupy of a devices real state, with Prebid Server (PBS) deriving a limited set of ad sizes (max 10) as eligible for the auction.
+* `configId` - an ID of Stored Impression on the Prebid Server
+* `minWidthPerc`: Optional parameter to specify the minimum width percent an ad may occupy of a device's real estate. Support in SDK version 1.2+
+* `minHeightPrec`: Optional parameter to specify the minimum height percent an ad may occupy of a device's real estate. Support in SDK version 1.2+
 
+> **NOTE:** As of version 1.2+, Prebid SDK has extended the functionality of Interstitial ad monetization by using a smart ad size selection process to monetize sizes smaller than full screen ads. App developers can specify a minimum width and minimum height percentage an ad can occupy of a devices real state, with Prebid Server (PBS) deriving a limited set of ad sizes (max 10) as eligible for the auction.
+>
 > PBS will take the AdUnit's size (width and height) as the max size for the interstitial as size, generating a list of ad sizes, selecting the first 10 sizes that fall within the imp's max size and minimum percentage size. All the interstitial parameters will still be passed to the bidders, allowing them to use their own size matching algorithms if they prefer.
-
+>
 > Prebid Server will send the eligible size list to each bidder to solicit a bid. For a full description of the Prebid Server logic, please refer to the [Prebid Server PR 797](https://github.com/prebid/prebid-server/pull/797/files).
 
 {: .alert.alert-warning :}
@@ -426,12 +426,12 @@ Starting from PrebidMobile `2.1.0` the `parameters` property is deprecated. Use
 #### Step 2: Make a bid request
 {:.no_toc}
 
-The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests. 
+The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests.
 
 #### Step 3: Load a GAM interstitial ad
 {:.no_toc}
 
-You should now request the ad from GAM. If the `GAMRequest` contains targeting keywords. The respective Prebid line item will be returned from GAM and GMA SDK will render its creative. 
+You should now request the ad from GAM. If the `GAMRequest` contains targeting keywords. The respective Prebid line item will be returned from GAM and GMA SDK will render its creative.
 
 Be sure that you make the ad request with the same `GAMRequest` object that you passed to the `fetchDemand` method. Otherwise the ad request won't contain targeting keywords and Prebid's ad won't ever be displayed.
 
@@ -444,7 +444,7 @@ Follow the [GMA SDK guide](https://developers.google.com/ad-manager/mobile-ads-s
 
 Integration Example:
 
-```swift
+``` swift
 // 1. Create a InterstitialAdUnit
 adUnit = InterstitialAdUnit(configId: CONFIG_ID)
 
@@ -461,7 +461,7 @@ adUnit.videoParameters = parameters
 let gamRequest = GAMRequest()
 adUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
     PrebidDemoLogger.shared.info("Prebid demand fetch for GAM \(resultCode.name())")
-   
+
 // 5. Load a GAM interstitial ad
 GAMInterstitialAd.load(withAdManagerAdUnitID: gamAdUnitVideoInterstitialOriginal, request: gamRequest) { ad, error in
     guard let self = self else { return }
@@ -478,20 +478,19 @@ GAMInterstitialAd.load(withAdManagerAdUnitID: gamAdUnitVideoInterstitialOriginal
 ```
 
 {: .alert.alert-warning :}
-Starting from PrebidMobile `2.1.0` the `VideoInterstitialAdUnit` class is deprecated. Use `InterstitialAdUnit` class with video ad format instead. 
+Starting from PrebidMobile `2.1.0` the `VideoInterstitialAdUnit` class is deprecated. Use `InterstitialAdUnit` class with video ad format instead.
 
 #### Step 1: Create an Ad Unit
 {:.no_toc}
 
 Initialize the Interstitial Video Ad Unit with properties:
-    
-- `configId` - an ID of Stored Impression on the Prebid Server
 
+* `configId` - an ID of Stored Impression on the Prebid Server
 
 #### Step 2: Set ad format
 {:.no_toc}
 
-For video ad unit, you must set video ad format. Default value for `adFormats` property is `[.banner]`. 
+For video ad unit, you must set video ad format. Default value for `adFormats` property is `[.banner]`.
 
 #### Step 3: Configure video parameters
 {:.no_toc}
@@ -501,12 +500,12 @@ Provide configuration properties for the video ad using the [VideoParameters](#s
 #### Step 4: Make a bid request
 {:.no_toc}
 
-The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests. 
+The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests.
 
 #### Step 5: Load a GAM interstitial ad
 {:.no_toc}
 
-Now you should request the ad from GAM. If the `GAMRequest` contains targeting keywords. The respective Prebid line item will be returned from GAM and GMA SDK will render its creative. 
+Now you should request the ad from GAM. If the `GAMRequest` contains targeting keywords. The respective Prebid line item will be returned from GAM and GMA SDK will render its creative.
 
 Be sure that you make the ad request with the same `GAMRequest` object that you passed to the `fetchDemand` method. Otherwise the ad request won't contain targeting keywords and Prebid's ad won't ever be displayed.
 
@@ -519,7 +518,7 @@ Follow the [GMA SDK guide](https://developers.google.com/ad-manager/mobile-ads-s
 
 Integration example:
 
-```swift
+``` swift
 // 1. Create an InterstitialAdUnit
 adUnit = InterstitialAdUnit(configId: CONFIG_ID, minWidthPerc: 60, minHeightPerc: 70)
 
@@ -536,11 +535,11 @@ adUnit.videoParameters = parameters
 let gamRequest = GAMRequest()
 adUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
     PrebidDemoLogger.shared.info("Prebid demand fetch for GAM \(resultCode.name())")
-    
+
     // 5. Load a GAM interstitial ad
     GAMInterstitialAd.load(withAdManagerAdUnitID: gamAdUnitMultiformatInterstitialOriginal, request: gamRequest) { ad, error in
         guard let self = self else { return }
-        
+
         if let error = error {
             PrebidDemoLogger.shared.error("Failed to load interstitial ad with error: \(error.localizedDescription)")
         } else if let ad = ad {
@@ -556,21 +555,21 @@ adUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
 {:.no_toc}
 
 Initialize the InterstitialAdUnit with the following properties:
-    
-- `configId` - an ID of Stored Impression on the Prebid Server
-- `minWidthPerc`: Optional parameter to specify the minimum width percent an ad may occupy of a device's real estate. Support in SDK version 1.2+
-- `minHeightPrec`: Optional parameter to specify the minimum height percent an ad may occupy of a device's real estate. Support in SDK version 1.2+
 
-> **NOTE:** As of version 1.2+, Prebid SDK has extended the functionality of Interstitial ad monetization by using a smart ad size selection process to monetize sizes smaller than full screen ads. App developers can specify a minimum width and minimum height percentage an ad can occupy of a devices real state, with Prebid Server (PBS) deriving a limited set of ad sizes (max 10) as eligible for the auction.
+* `configId` - an ID of Stored Impression on the Prebid Server
+* `minWidthPerc`: Optional parameter to specify the minimum width percent an ad may occupy of a device's real estate. Support in SDK version 1.2+
+* `minHeightPrec`: Optional parameter to specify the minimum height percent an ad may occupy of a device's real estate. Support in SDK version 1.2+
 
+> **NOTE:** As of version 1.2+, Prebid SDK has extended the functionality of Interstitial ad monetization by using a smart ad size selection process to monetize sizes smaller than full screen ads. App developers can specify a minimum width and minimum height percentage an ad can occupy of a devices real state, with Prebid Server (PBS) deriving a limited set of ad sizes (max 10) as eligible for the auction.
+>
 > PBS will take the AdUnit's size (width and height) as the max size for the interstitial as size, generating a list of ad sizes, selecting the first 10 sizes that fall within the imp's max size and minimum percentage size. All the interstitial parameters will still be passed to the bidders, allowing them to use their own size matching algorithms if they prefer.
-
+>
 > Prebid Server will send the eligible size list to each bidder to solicit a bid. For a full description of the Prebid Server logic, please refer to the [Prebid Server PR 797](https://github.com/prebid/prebid-server/pull/797/files).
 
 #### Step 2: Set ad formats
 {:.no_toc}
 
-For multiformat ad unit, you must set both banner and video ad formats. 
+For multiformat ad unit, you must set both banner and video ad formats.
 
 #### Step 3: Configure parameters
 {:.no_toc}
@@ -581,12 +580,12 @@ Provide configuration properties for the video ad using the [VideoParameters](#s
 #### Step 4: Make a bid request
 {:.no_toc}
 
-The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests. 
+The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests.
 
 #### Step 5: Load a GAM interstitial ad
 {:.no_toc}
 
-You should now request the ad from GAM. If the `GAMRequest` contains targeting keywords. The respective Prebid line item will be returned from GAM and GMA SDK will render its creative. 
+You should now request the ad from GAM. If the `GAMRequest` contains targeting keywords. The respective Prebid line item will be returned from GAM and GMA SDK will render its creative.
 
 Be sure that you make the ad request with the same `GAMRequest` object that you passed to the `fetchDemand` method. Otherwise the ad request won't contain targeting keywords and Prebid's ad won't ever be displayed.
 
@@ -599,7 +598,7 @@ Follow the [GMA SDK guide](https://developers.google.com/ad-manager/mobile-ads-s
 
 Integration example:
 
-```swift
+``` swift
 // 1. Create a RewardedVideoAdUnit
 adUnit = RewardedVideoAdUnit(configId: CONFIG_ID)
 
@@ -612,7 +611,7 @@ adUnit.videoParameters = parameters
 // 3. Make a bid request to Prebid Server
 adUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
     PrebidDemoLogger.shared.info("Prebid demand fetch for GAM \(resultCode.name())")
-   
+
     // 4. Load a GAM Rewarded Ad
     GADRewardedAd.load(withAdUnitID: gamAdUnitVideoRewardedOriginal, request: self?.gamRequest) { [weak self] ad, error in
         guard let self = self else { return }
@@ -620,7 +619,7 @@ adUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
             PrebidDemoLogger.shared.error("Failed to load rewarded ad with error: \(error.localizedDescription)")
         } else if let ad = ad {
             ad.fullScreenContentDelegate = self
-            
+
             // 5. Present the interstitial ad
             ad.present(fromRootViewController: self, userDidEarnRewardHandler: {
                 _ = ad.adReward
@@ -629,14 +628,15 @@ adUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
     }
 }
 ```
-#### Step 1: Create a RewardedVideoAdUnit
+
+### Step 1: Create a RewardedVideoAdUnit
 {:.no_toc}
 
 Initialize the Rewarded Video Ad Unit with properties:
-    
-- `configId` - an ID of Stored Impression on the Prebid Server
 
-#### Step 2: Configure video parameters
+* `configId` - an ID of Stored Impression on the Prebid Server
+
+### Step 2: Configure video parameters
 {:.no_toc}
 
 Provide configuration properties for the video ad using the [VideoParameters](#step-3-configure-the-video-parameters) object.
@@ -644,28 +644,28 @@ Provide configuration properties for the video ad using the [VideoParameters](#s
 {: .alert.alert-warning :}
 Please, note that starting from PrebidMobile `2.1.0` the `parameters` property is deprecated. Use `videoParameters` instead.
 
-#### Step 3: Make a bid request
+### Step 3: Make a bid request
 {:.no_toc}
 
-The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests. 
+The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests.
 
-#### Step 4: Load a GAM Rewarded Ad
+### Step 4: Load a GAM Rewarded Ad
 {:.no_toc}
 
-Now you should request the ad from GAM. If the `GAMRequest` contains targeting keywords. The respective Prebid line item will be returned from GAM and GMA SDK will render its creative. 
+Now you should request the ad from GAM. If the `GAMRequest` contains targeting keywords. The respective Prebid line item will be returned from GAM and GMA SDK will render its creative.
 
 Be sure that you make the ad request with the same `GAMRequest` object that you passed to the `fetchDemand` method. Otherwise the ad request won't contain targeting keywords and Prebid's ad won't ever be displayed.
 
-#### Step 5: Present the Rewarded Ad
+### Step 5: Present the Rewarded Ad
 {:.no_toc}
 
 Follow the [GMA SDK guide](https://developers.google.com/ad-manager/mobile-ads-sdk/ios/rewarded#show_the_ad) to display a rewarded ad right after receiving it or later in natural pauses in the flow of an app.
 
 ## Instream Video API
 
-Integration example: 
+Integration example:
 
-```swift
+``` swift
 // 1. Create InstreamVideoAdUnit
 adUnit = InstreamVideoAdUnit(configId: CONFIG_ID, size: CGSize(width: 1,height: 1))
 
@@ -684,10 +684,10 @@ adUnit.fetchDemand { [weak self] (resultCode, prebidKeys: [String: String]?) in
     guard let self = self else { return }
     if resultCode == .prebidDemandFetchSuccess {
         do {
-            
+
             // 5. Generate GAM Instream URI
             let adServerTag = try IMAUtils.shared.generateInstreamUriForGAM(adUnitID: gamAdUnitVideo, adSlotSizes: [.Size320x480], customKeywords: prebidKeys!)
-            
+
             // 6. Load IMA ad request
             let adDisplayContainer = IMAAdDisplayContainer(adContainer: self.instreamView, viewController: self)
             let request = IMAAdsRequest(adTagUrl: adServerTag, adDisplayContainer: adDisplayContainer, contentPlayhead: nil, userContext: nil)
@@ -711,7 +711,7 @@ func adsLoader(_ loader: IMAAdsLoader, adsLoadedWith adsLoadedData: IMAAdsLoaded
     // Grab the instance of the IMAAdsManager and set ourselves as the delegate.
     adsManager = adsLoadedData.adsManager
     adsManager?.delegate = self
-    
+
     // Initialize the ads manager.
     adsManager?.initialize(with: nil)
 }
@@ -745,51 +745,50 @@ func adsManagerDidRequestContentResume(_ adsManager: IMAAdsManager) {
     // The SDK is done playing ads (at least for now), so resume the content.
     contentPlayer?.play()
 }
-``` 
+```
 
 {: .alert.alert-warning :}
-Starting from PrebidMobile `2.1.0` the `VideoAdUnit` class is deprecated. Use `InstreamVideoAdUnit` class instead. 
+Starting from PrebidMobile `2.1.0` the `VideoAdUnit` class is deprecated. Use `InstreamVideoAdUnit` class instead.
 
-#### Step 1: Create an InstreamVideoAdUnit
+### Step 1: Create an InstreamVideoAdUnit
 {:.no_toc}
 
 Initialize the Instream Video Ad Unit with properties:
-    
-- `configId` - an ID of Stored Impression on the Prebid Server
-- `size` - Width and height of the video ad unit.
 
-#### Step 2: Configure video parameters
+* `configId` - an ID of Stored Impression on the Prebid Server
+* `size` - Width and height of the video ad unit.
+
+### Step 2: Configure video parameters
 {:.no_toc}
 
 Provide configuration properties for the video ad using the [VideoParameters](#step-3-configure-the-video-parameters) object.
 
-#### Step 3: Prepare IMAAdsLoader
+### Step 3: Prepare IMAAdsLoader
 {:.no_toc}
 
 Prepare the in-stream setup according to the [Google's docs](https://developers.google.com/interactive-media-ads/docs/sdks/ios/client-side).
 
-#### Step 4: Make a bid request
+### Step 4: Make a bid request
 {:.no_toc}
 
-The `fetchDemand` method makes a bid request to the Prebid Server. You should use the version of the `fetchDemand` which returns the targeting keywords in the callback. Later you will construct the IMA ad request using these keywords. 
+The `fetchDemand` method makes a bid request to the Prebid Server. You should use the version of the `fetchDemand` which returns the targeting keywords in the callback. Later you will construct the IMA ad request using these keywords.
 
-#### Step 5: Generate GAM Instream URI
+### Step 5: Generate GAM Instream URI
 {:.no_toc}
 
 Using Prebid util method, generate Google IMA URI for downloading the cached creative from the winning bid.
 
-#### Step 6: Load IMA ad request
+### Step 6: Load IMA ad request
 {:.no_toc}
 
-Create an ad display container for ad rendering. Then create an ad request with our ad tag, display container, and optional user context. Load the ad. Follow the [in-stream video guide](https://developers.google.com/interactive-media-ads/docs/sdks/ios/client-side#6_initialize_the_ads_loader_and_make_an_ads_request) for additional details.  
-
+Create an ad display container for ad rendering. Then create an ad request with our ad tag, display container, and optional user context. Load the ad. Follow the [in-stream video guide](https://developers.google.com/interactive-media-ads/docs/sdks/ios/client-side#6_initialize_the_ads_loader_and_make_an_ads_request) for additional details.
 
-#### Step 7: Set up an ads loader delegate
+### Step 7: Set up an ads loader delegate
 {:.no_toc}
 
 On a successful load event, the `IMAAdsLoader` calls the adsLoadedWithData method of its assigned delegate, passing it an instance of `IMAAdsManager`. You can then initialize the ads manager, which loads the individual ads as defined by the response to the ad tag URL.
 
-#### Step 8: Set up an ads manager delegate
+### Step 8: Set up an ads manager delegate
 {:.no_toc}
 
 Lastly, to manage events and state changes, the ads manager needs a delegate of its own. The `IMAAdManagerDelegate` has methods to handle ad events and errors, as well as methods to trigger play and pause on your video content.
@@ -802,26 +801,26 @@ Integration example:
 
 Prepare the set of requested assets first.
 
-```swift
+``` swift
 private var nativeRequestAssets: [NativeAsset] {
     let image = NativeAssetImage(minimumWidth: 200, minimumHeight: 50, required: true)
     image.type = ImageAsset.Main
-    
+
     let icon = NativeAssetImage(minimumWidth: 20, minimumHeight: 20, required: true)
     icon.type = ImageAsset.Icon
-    
+
     let title = NativeAssetTitle(length: 90, required: true)
     let body = NativeAssetData(type: DataAsset.description, required: true)
     let cta = NativeAssetData(type: DataAsset.ctatext, required: true)
     let sponsored = NativeAssetData(type: DataAsset.sponsored, required: true)
-    
+
     return [title, icon, image, sponsored, body, cta]
 }
 ```
 
-Then integrate the native style ad using GAM Banner ad unit 
+Then integrate the native style ad using GAM Banner ad unit
 
-```swift
+``` swift
 // 1. Create NativeRequest
 nativeUnit = NativeRequest(configId: CONFIG_ID, assets: nativeRequestAssets)
 nativeUnit.context = ContextType.Social
@@ -839,7 +838,7 @@ bannerView.addSubview(gamBannerView)
 // 3. Make a bid request
 nativeUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
     PrebidDemoLogger.shared.info("Prebid demand fetch for GAM \(resultCode.name())")
-    
+
     // 4. Load and GAM ad
     self?.gamBannerView.load(self?.gamRequest)
 }
@@ -850,8 +849,8 @@ nativeUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
 
 Initialize the `NativeRequest` with properties:
 
-- `configId` - an ID of the Stored Impression on the Prebid Server
-- `assets` - the array of `NativeAsset` objects which describes your native ad.
+* `configId` - an ID of the Stored Impression on the Prebid Server
+* `assets` - the array of `NativeAsset` objects which describes your native ad.
 
 ##### NativeAssetImage
 {:.no_toc}
@@ -880,21 +879,20 @@ Initialize the `NativeRequest` with properties:
 |-------|--------|---------|
 | Title | Optional | The title of the native ad. |
 
-
 #### Step 2: Create a GAMBannerView
 {:.no_toc}
 
-Just follow the [GMA SDK documentation](https://developers.google.com/ad-manager/mobile-ads-sdk/ios/banner) to integrate a banner ad unit. 
+Just follow the [GMA SDK documentation](https://developers.google.com/ad-manager/mobile-ads-sdk/ios/banner) to integrate a banner ad unit.
 
 #### Step 3: Make a bid request
 {:.no_toc}
 
-The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests. 
+The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests.
 
 #### Step 4: Load an Ad
 {:.no_toc}
 
-You should now request the ad from GAM. If the `GAMRequest` contains targeting keywords the respective Prebid line item will be returned from GAM and GMA SDK will render its creative. 
+You should now request the ad from GAM. If the `GAMRequest` contains targeting keywords the respective Prebid line item will be returned from GAM and GMA SDK will render its creative.
 
 Be sure that you make the ad request with the same `GAMRequest` object that you passed to the `fetchDemand` method. Otherwise the ad request won't contain targeting keywords and Prebid's ad won't ever be displayed.
 
@@ -917,15 +915,15 @@ The cached assets might expire. If this occurs the publisher will receive a noti
 
 These instructions will enable you to create a creative template in either Google Ad Manager that can then be applied to native ads in your app.
 
-1. Sign in to Google Ad Manager.
-2. Create an ad unit with fluid ad size.
-3. Click `Delivery` and then `Native`
-4. Click `Create native ad`.
-5. Click `Android & iOS app code`.
-6. Name your new format.
-7. Choose `ADD VARIABLE` and add the following variable names and placeholders.  
+* `Step 1`: Sign in to Google Ad Manager.
+* `Step 2`: Create an ad unit with fluid ad size.
+* `Step 3`: Click `Delivery` and then `Native`
+* `Step 4`: Click `Create native ad`.
+* `Step 5`: Click `Android & iOS app code`.
+* `Step 6`: Name your new format.
+* `Step 7`: Choose `ADD VARIABLE` and add the following variable names and placeholders.
 
-{: .table .table-bordered .table-striped }  
+{: .table .table-bordered .table-striped }
 | Variable Name| Placeholder|
 |--------------+------------|
 | isPrebid            | [%isPrebid%]                |
@@ -933,41 +931,41 @@ These instructions will enable you to create a creative template in either Googl
 
 Make sure to indicate that the variables are required.
 
-8. Return to the home screen, click `Delivery > Creatives`, and create a creative with `Native Format`, choosing the template you created. In the user-defined variables you just created, set the following values:
+* `Step 8`: Return to the home screen, click `Delivery > Creatives`, and create a creative with `Native Format`, choosing the template you created. In the user-defined variables you just created, set the following values:
 
-  {: .table .table-bordered .table-striped }  
+{: .table .table-bordered .table-striped }
 | Variable Name       | Value                            |
 |---------------------+----------------------------------|
 | isPrebid            | 1                                |
 | hb_cache_id_local   | %%PATTERN:hb_cache_id_local%%    |
 
-9. Create Prebid line items with price priority and a display ad type that is targeting `hb_pb key-values`. Associate the creative you added in steps 4 thru 8 (making sure to choose your native format as expected creatives on the line item) to the ad unit you created in the second step.
+* `Step 9`: Create Prebid line items with price priority and a display ad type that is targeting `hb_pb key-values`. Associate the creative you added in steps 4 thru 8 (making sure to choose your native format as expected creatives on the line item) to the ad unit you created in the second step.
 
 #### Integration Example
 {:.no_toc}
 
 Prepare the set of requested assets first.
 
-```swift
+``` swift
 private var nativeRequestAssets: [NativeAsset] {
     let image = NativeAssetImage(minimumWidth: 200, minimumHeight: 50, required: true)
     image.type = ImageAsset.Main
-    
+
     let icon = NativeAssetImage(minimumWidth: 20, minimumHeight: 20, required: true)
     icon.type = ImageAsset.Icon
-    
+
     let title = NativeAssetTitle(length: 90, required: true)
     let body = NativeAssetData(type: DataAsset.description, required: true)
     let cta = NativeAssetData(type: DataAsset.ctatext, required: true)
     let sponsored = NativeAssetData(type: DataAsset.sponsored, required: true)
-    
+
     return [title, icon, image, sponsored, body, cta]
 }
 ```
 
-Then integrate the native style ad using GADAdLoader 
+Then integrate the native style ad using GADAdLoader
 
-```swift
+``` swift
 // 1. Setup NativeRequest
 nativeUnit = NativeRequest(configId: storedPrebidImpression, assets: nativeRequestAssets)
 nativeUnit.context = ContextType.Social
@@ -978,7 +976,7 @@ nativeUnit.eventtrackers = eventTrackers
 // 2. Make a bid request
 nativeUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
     guard let self = self else { return }
-    
+
     //3. Configure and make a GAM ad request
     self.adLoader = GADAdLoader(adUnitID: gamRenderingNativeAdUnitId,rootViewController: self,
                                 adTypes: [GADAdLoaderAdType.customNative], options: [])
@@ -986,7 +984,7 @@ nativeUnit.fetchDemand(adObject: gamRequest) { [weak self] resultCode in
     self.adLoader.load(self.gamRequest)
 }
 
-..... 
+.....
 
 // Step 4
 // MARK: GADCustomNativeAdLoaderDelegate
@@ -1007,7 +1005,7 @@ func nativeAdLoaded(ad: NativeAd) {
     nativeAd = ad
     titleLabel.text = ad.title
     bodyLabel.text = ad.text
-    
+
     if let iconString = ad.iconUrl {
         ImageHelper.downloadImageAsync(iconString) { result in
             if case let .success(icon) = result {
@@ -1017,7 +1015,7 @@ func nativeAdLoaded(ad: NativeAd) {
             }
         }
     }
-    
+
     if let imageString = ad.imageUrl {
         ImageHelper.downloadImageAsync(imageString) { result in
             if case let .success(image) = result {
@@ -1027,10 +1025,10 @@ func nativeAdLoaded(ad: NativeAd) {
             }
         }
     }
-    
+
     callToActionButton.setTitle(ad.callToAction, for: .normal)
     sponsoredLabel.text = ad.sponsoredBy
-    
+
     nativeAd.registerView(view: view, clickableViews: [callToActionButton])
 }
 
@@ -1041,59 +1039,275 @@ func nativeAdNotFound() {
 func nativeAdNotValid() {
     PrebidDemoLogger.shared.error("Native ad not valid")
 }
-
 ```
 
-#### Step 1: Create a NativeRequest
+##### Step 1: Create a NativeRequest
 {:.no_toc}
 
 Initialize the `NativeRequest` with properties:
 
-- `configId` - an ID of the Stored Impression on the Prebid Server
-- `assets` - the array of [NativeAsset](#step-1-Create-a-NativeRequest) objects which describes your native ad.
+* `configId` - an ID of the Stored Impression on the Prebid Server
+* `assets` - the array of `NativeAsset` objects which describes your native ad.
 
-#### Step 2: Make a bid request
+##### Step 2: Make a bid request
 {:.no_toc}
 
-The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests. 
+The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests.
 
-#### Step 3: Configure and make a GAM ad request
+##### Step 3: Configure and make a GAM ad request
 {:.no_toc}
 
 Prepare the `GADAdLoader` and run ad request as described in the GMA SDK docs for the [native ads](https://developers.google.com/ad-manager/mobile-ads-sdk/ios/native/start).
 
-If the `GAMRequest` contains targeting keywords the respective Prebid line item will be returned from GAM and GMA SDK will render its creative. 
+If the `GAMRequest` contains targeting keywords the respective Prebid line item will be returned from GAM and GMA SDK will render its creative.
 
 Be sure that you make the ad request with the same `GAMRequest` object that you passed to the `fetchDemand` method. Otherwise the ad request won't contain targeting keywords and Prebid's ad won't ever be displayed.
 
-#### Step 4: Implement GADCustomNativeAdLoaderDelegate protocol
+##### Step 4: Implement GADCustomNativeAdLoaderDelegate protocol
 {:.no_toc}
 
-In order to capture the native ad response you need to implement [GADCustomNativeAdLoaderDelegate](GADCustomNativeAdLoaderDelegate) protocol. 
- 
+In order to capture the native ad response you need to implement [GADCustomNativeAdLoaderDelegate](GADCustomNativeAdLoaderDelegate) protocol.
+
 In the method `-adLoader:didReceiveCustomNativeAd:` you should pass the following Prebid functions:
 
-```
+``` swift
 Utils.shared.delegate = self
 Utils.shared.findNative(adObject: customNativeAd)
 ```
 
 Without it the SDK won't be able to recognize the Prebid line item.
 
-#### Step 5: Implement NativeAdDelegate
+##### Step 5: Implement NativeAdDelegate
+{:.no_toc}
+
+Once the Prebid line item is recognized, the `NativeAdDelegate` will be activated. The method `nativeAdLoaded` will be invoked and provide the `NativeAd` object with a description of all ad assets that should be rendered.
+
+## Multiformat API
+
+Starting with version `2.1.5` Prebid SDK supports the fully multiformat ad unit. It allows to run bid requests with any combination of `banner`, `video`, and `native` formats.
+
+The following code demonstrates the integration of multiformat ad unit.
+
+``` swift
+func createAd() {
+    // 1. Setup a PrebidAdUnit
+    adUnit = PrebidAdUnit(configId: configId)
+    adUnit.setAutoRefreshMillis(time: 30_000)
+
+    // 2. Setup the parameters
+    let bannerParameters = BannerParameters()
+    bannerParameters.api = [Signals.Api.MRAID_2]
+    bannerParameters.adSizes = [adSize]
+
+    let videoParameters = VideoParameters(mimes: ["video/mp4"])
+    videoParameters.protocols = [Signals.Protocols.VAST_2_0]
+    videoParameters.playbackMethod = [Signals.PlaybackMethod.AutoPlaySoundOff]
+    videoParameters.placement = Signals.Placement.InBanner
+    videoParameters.adSize = adSize
+
+    let nativeParameters = NativeParameters()
+    nativeParameters.assets = nativeAssets
+    nativeParameters.context = ContextType.Social
+    nativeParameters.placementType = PlacementType.FeedContent
+    nativeParameters.contextSubType = ContextSubType.Social
+    nativeParameters.eventtrackers = eventTrackers
+
+    // 3. Configure the PrebidRequest
+    let prebidRequest = PrebidRequest(bannerParameters: bannerParameters, videoParameters: videoParameters, nativeParameters: nativeParameters)
+
+    // 4. Make a bid request
+    let gamRequest = GAMRequest()
+    adUnit.fetchDemand(adObject: gamRequest, request: prebidRequest) { [weak self] _ in
+        guard let self = self else { return }
+
+        // 5. Configure and make a GAM ad request
+        self.adLoader = GADAdLoader(adUnitID: gamRenderingMultiformatAdUnitId, rootViewController: self,
+                                    adTypes: [GADAdLoaderAdType.customNative, GADAdLoaderAdType.gamBanner], options: [])
+        self.adLoader.delegate = self
+        self.adLoader.load(gamRequest)
+    }
+}
+```
+
+To handle the banner, video and in-banner native (Native Styles) ads:
+
+``` swift
+func adLoader(_ adLoader: GADAdLoader, didReceive bannerView: GAMBannerView) {
+    self.bannerView.isHidden = false
+    self.nativeView.isHidden = true
+    self.bannerView.backgroundColor = .clear
+    self.bannerView.addSubview(bannerView)
+
+    AdViewUtils.findPrebidCreativeSize(bannerView, success: { [weak self] size in
+        bannerView.resize(GADAdSizeFromCGSize(size))
+
+        self?.bannerView.constraints.first { $0.firstAttribute == .width }?.constant = size.width
+        self?.bannerView.constraints.first { $0.firstAttribute == .height }?.constant = size.height
+    }, failure: { (error) in
+        PrebidDemoLogger.shared.error("Error occuring during searching for Prebid creative size: \(error)")
+    })
+}
+```
+
+If you use Custom Native Ads follow the [guide](https://developers.google.com/ad-manager/mobile-ads-sdk/ios/native-banner) on how to implement processing of the ad response of the respective type. To handle the wining native ad:
+
+``` swift
+// MARK: - NativeAdDelegate
+
+func nativeAdLoaded(ad: NativeAd) {
+    nativeView.isHidden = false
+    bannerView.isHidden = true
+
+    nativeAd = ad
+    titleLabel.text = ad.title
+    bodyLabel.text = ad.text
+
+    if let iconString = ad.iconUrl {
+        ImageHelper.downloadImageAsync(iconString) { result in
+            if case let .success(icon) = result {
+                DispatchQueue.main.async {
+                    self.iconView.image = icon
+                }
+            }
+        }
+    }
+
+    if let imageString = ad.imageUrl {
+        ImageHelper.downloadImageAsync(imageString) { result in
+            if case let .success(image) = result {
+                DispatchQueue.main.async {
+                    self.mainImageView.image = image
+                }
+            }
+        }
+    }
+
+    callToActionButton.setTitle(ad.callToAction, for: .normal)
+    sponsoredLabel.text = ad.sponsoredBy
+
+    nativeAd.registerView(view: view, clickableViews: [callToActionButton])
+}
+```
+
+### Step 1: Create a PrebidAdUnit
+{:.no_toc}
+
+Initialize the `PrebidAdUnit` with the following properties:
+
+* `configId` - an ID of the Stored Impression on the Prebid Server
+
+### Step 2: Setup the parameters
+{:.no_toc}
+
+For each intersted ad format you should creatae a respective configuration parameter:
+
+* [BannerParameters](#step-2-configure-banner-parameters) object.
+* [VideoParameters](#step-3-configure-the-video-parameters) object.
+* [NativeParameters](#nativeparameters) object
+
+#### NativeParameters
+{:.no_toc}
+
+Using the `NativeParameters` you can customize the bid request for video ads.
+
+##### assets
+{:.no_toc}
+
+The array of requested asset objects. Prebid SDK supports all kinds of assets according to the [IAB spec](https://iabtechlab.com/wp-content/uploads/2016/07/OpenRTB-Native-Ads-Specification-Final-1.2.pdf)  except `video`.
+
+##### eventtrackers
+{:.no_toc}
+
+The array of requested native trackers. Prebid SDK supports inly `image` trackers according to the [IAB spec](https://iabtechlab.com/wp-content/uploads/2016/07/OpenRTB-Native-Ads-Specification-Final-1.2.pdf).
+
+##### version
+{:.no_toc}
+
+Version of the Native Markup version in use. The default value is `1.2`
+
+##### context
+{:.no_toc}
+
+The context in which the ad appears.
+
+##### contextSubType
+{:.no_toc}
+
+A more detailed context in which the ad appears.
+
+##### placementType
+{:.no_toc}
+
+The design/format/layout of the ad unit being offered.
+
+##### placementCount
+{:.no_toc}
+
+The number of identical placements in this Layout.
+
+##### sequence
+{:.no_toc}
+
+0 for the first ad, 1 for the second ad, and so on.
+
+##### asseturlsupport
+{:.no_toc}
+
+Whether the supply source/impression supports returning an assetsurl instead of an asset object. 0 or the absence of the field indicates no such support.
+
+##### durlsupport
+{:.no_toc}
+
+Whether the supply source / impression supports returning a dco url instead of an asset object. 0 or the absence of the field indicates no such support.
+
+##### privacy
+{:.no_toc}
+
+Set to 1 when the native ad supports buyer-specific privacy notice.  Set to 0 (or field absent) when the native ad doesn’t support custom privacy links or if support is unknown.
+
+##### ext
+{:.no_toc}
+
+This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification
+
+### Step 3: Create PrebidRequest
+{:.no_toc}
+
+Create the instance of `PrebidRequest` initializing it with respective ad format parameters.
+
+In addition you can set the following properties of the `PrebidRequest`.
+
+### Step 4: Make a bid request
+{:.no_toc}
+
+The `fetchDemand` method makes a bid request to the Prebid Server. You should provide a `GAMRequest` object to this method so Prebid SDK sets the targeting keywords of the winning bid for future ad requests.
+
+### Step 5: Create a GAMBannerView
+{:.no_toc}
+
+Follow the [GMA SDK documentation](https://developers.google.com/ad-manager/mobile-ads-sdk/ios/banner) to integrate a banner ad unit.
+
+### Step 6: Load an Ad
+{:.no_toc}
+
+Now you should request the ad from GAM. If the `GAMRequest` contains targeting keywords, the respective Prebid line item will be returned from GAM and GMA SDK will render its creative.
+
+Be sure that you make the ad request with the same `GAMRequest` object that you passed to the `fetchDemand` method. Otherwise, the ad request won't contain targeting keywords, and Prebid's ad won't ever be displayed.
+
+### Step 7: Process the Ad Response
 {:.no_toc}
 
-Once the Prebid line item is recognized, the `NativeAdDelegate` will be activated. The method `nativeAdLoaded` will be invoked and provide the `NativeAd` object with a description of all ad assets that should be rendered. 
+Once an app receives a signal that an ad is loaded, you should use the method `AdViewUtils.findPrebidCreativeSize` to verify whether it is a Prebid ad and resize the ad slot respectively to the creative's properties.
 
 ## Ad Unit Configuration
 
-Each ad unit in the original API is a subclass of the `AdUnit` class, which provides the following properties and methods for the additional configuration. 
+Each ad unit in the original API is a subclass of the `AdUnit` class, which provides the following properties and methods for the additional configuration.
 
 ### Ad Slot
 
 PB Ad Slot is an identifier tied to the placement the ad will be delivered in. The use case for PB Ad Slot is to pass to exchange an ID they can use to tie to reporting systems or use for data science driven model building to match with impressions sourced from alternate integrations. A common ID to pass is the ad server slot name.
 
-```
+``` swift
 adUnit.ortb2Imp.ext.data.pbadslot = "/1111111/homepage/med-rect-2"`
 ```
 
@@ -1112,7 +1326,7 @@ Halts the auto-refresh behavior for a given Prebid Mobile ad unit. If no auto-re
 #### resumeAutoRefresh
 {:.no_toc}
 
-Allows to resume the stopped autorefresh for the ad unit with predefined autorefresh value. 
+Allows to resume the stopped autorefresh for the ad unit with predefined autorefresh value.
 
 ### Context Keyword
 
@@ -1121,7 +1335,7 @@ Allows to resume the stopped autorefresh for the ad unit with predefined autoref
 
 Ad Unit context keywords object is a free form list of comma separated keywords about the app as defined in app.keyword in OpenRTB 2.5. The `addContextKeyword` function adds a single keyword to the ad unit.
 
-```
+``` swift
 func addContextKeyword(_ newElement: String)
 ```
 
@@ -1130,21 +1344,21 @@ func addContextKeyword(_ newElement: String)
 
 Ad Unit context keywords object is a free form list of comma separated keywords about the app as defined in app.keyword in OpenRTB 2.5. The `addContextKeywords` function adds a multiple keyword to the ad unit.
 
-```
+``` swift
 func addContextKeywords(_ newElements: Set<String>)
 ```
 
 #### removeContextKeyword
 {:.no_toc}
 
-```
+``` swift
 func removeContextKeyword(_ element: String)
 ```
 
 ### clearContextKeywords
 {:.no_toc}
 
-```
+``` swift
 func clearContextKeywords()
 ```
 
@@ -1152,38 +1366,38 @@ func clearContextKeywords()
 
 The `ContentObject` allows you to provide more details about content within the app. All properties provided to the `ContentObject` will be sent in the `app.content` field of the bid request.
 
-```
-func setAppContent(_ appContent: ContentObject) 
+``` swift
+func setAppContent(_ appContent: ContentObject)
 
-func getAppContent() -> ContentObject? 
-      
-func clearAppContent() 
+func getAppContent() -> ContentObject?
+
+func clearAppContent()
 ```
-    
+
 ### App Content Data
 
-Using the following methods you can add `app.content.data` objects to the bid requests.  
-    
-```
-func addAppContentData(_ dataObjects: [ContentDataObject]) 
+Using the following methods you can add `app.content.data` objects to the bid requests.
 
-func removeAppContentData(_ dataObject: ContentDataObject) 
+``` swift
+func addAppContentData(_ dataObjects: [ContentDataObject])
 
-func clearAppContentData() 
+func removeAppContentData(_ dataObject: ContentDataObject)
+
+func clearAppContentData()
 ```
 
 ### User Data
 
-Using the following methods you can add `user.data` objects to the bid requests.  
+Using the following methods you can add `user.data` objects to the bid requests.
 
-```
-func getUserData() -> [PBMORTBContentData]? 
+``` swift
+func getUserData() -> [PBMORTBContentData]?
+
+func addUserData(_ userDataObjects: [PBMORTBContentData])
 
-func addUserData(_ userDataObjects: [PBMORTBContentData]) 
-  
-func removeUserData(_ userDataObject: PBMORTBContentData) 
-   
-func clearUserData() 
+func removeUserData(_ userDataObject: PBMORTBContentData)
+
+func clearUserData()
 ```
 
 ### Data Object
@@ -1191,6 +1405,7 @@ func clearUserData()
 The Data object is free form data (also known as First Party Data) supplied by the publisher to provide additional targeting of the user or inventory context, used primarily for striking PMP (Private MarketPlace) deals with Advertisers. Data supplied in the data parameters are typically not sent to DSPs whereas information sent in non-data objects (i.e. `setYearOfBirth`, `setGender`, etc.) will be. Access to FPD can be limited to a supplied set of Prebid bidders via an access control list.
 
 Data is broken up into two different data types:
+
 * User
   * Global in scope only
 * Inventory (context)
@@ -1202,7 +1417,7 @@ The first party inventory context below will apply to the specic ad unit the dat
 #### addContextData
 {:.no_toc}
 
-```
+``` swift
 func addContextData(key: String, value: String)
 ```
 
@@ -1210,11 +1425,10 @@ func addContextData(key: String, value: String)
 `key`: string containing the key for the specific data object
 `value`: String containing the value for the supplied key
 
-
 #### updateContextData
 {:.no_toc}
 
-```
+``` swift
 func updateContextData(key: String, value: Set<String>)
 ```
 
@@ -1222,11 +1436,10 @@ func updateContextData(key: String, value: Set<String>)
 `key`: string containing the key for the specific data object
 `value`: String containing the value for the supplied key
 
-
 #### removeContextData
 {:.no_toc}
 
-```
+``` swift
 func removeContextData(forKey: String)
 ```
 
@@ -1234,10 +1447,9 @@ func removeContextData(forKey: String)
 `key`: string containing the key for the specific data object
 `value`: String containing the value for the supplied key
 
-
 #### clearContextData
 {:.no_toc}
 
-```
+``` swift
 func clearContextData()
 ```