Native Ads - Ad Control Help Center

Overview

Native ads are ad formats that naturally integrate with your app’s UI. You can freely customize ad elements (title, image, description, etc.) to match your app design.

Key Features

Custom design that perfectly integrates with app UI
Individual access and placement of ad elements
Option to display advertiser profile information
Support for additional custom fields

Implementation Steps

Native ad implementation proceeds in the following steps:

Load ad
Create custom view
Bind view
Handle delegates

1. Load Ad

Create an AdropNativeAd instance and load the ad.

import AdropAds

class MyViewController: UIViewController {
    private var nativeAd: AdropNativeAd?

    override func viewDidLoad() {
        super.viewDidLoad()

        // Create native ad
        nativeAd = AdropNativeAd(unitId: "YOUR_NATIVE_UNIT_ID")
        nativeAd?.delegate = self

        // Load ad
        nativeAd?.load()
    }
}

@import AdropAds;

@interface MyViewController () <AdropNativeAdDelegate>
@property (nonatomic, strong) AdropNativeAd *nativeAd;
@end

@implementation MyViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    // Create native ad
    self.nativeAd = [[AdropNativeAd alloc] initWithUnitId:@"YOUR_NATIVE_UNIT_ID"];
    self.nativeAd.delegate = self;

    // Load ad
    [self.nativeAd load];
}

@end

Set Context ID

You can set a Context ID for contextual targeting.

// contextId is read-only — set via initializer
let nativeAd = AdropNativeAd(unitId: "YOUR_UNIT_ID", contextId: "tech")

// contextId is read-only — set via initializer
AdropNativeAd *nativeAd = [[AdropNativeAd alloc] initWithUnitId:@"YOUR_UNIT_ID" contextId:@"tech"];

Use test unit IDs during development. See the Test Unit IDs section.

2. Create Custom View

Compose your native ad view using Storyboard or code.

UIKit (Storyboard/XIB)

Create AdropNativeAdView in Storyboard and connect ad elements as IBOutlets.

import AdropAds

class NativeAdViewCell: UITableViewCell {
    @IBOutlet weak var nativeAdView: AdropNativeAdView!
    @IBOutlet weak var iconImageView: UIImageView!
    @IBOutlet weak var headlineLabel: UILabel!
    @IBOutlet weak var bodyLabel: UILabel!
    @IBOutlet weak var mediaView: UIView!
    @IBOutlet weak var callToActionButton: UIButton!

    // Advertiser profile (optional)
    @IBOutlet weak var advertiserLogoImageView: UIImageView!
    @IBOutlet weak var advertiserNameLabel: UILabel!

    func configure(with ad: AdropNativeAd) {
        // View binding (see next section)
    }
}

UIKit (Code)

import AdropAds

class NativeAdView: UIView {
    let nativeAdView = AdropNativeAdView()
    let iconImageView = UIImageView()
    let headlineLabel = UILabel()
    let bodyLabel = UILabel()
    let mediaView = UIView()
    let callToActionButton = UIButton()

    override init(frame: CGRect) {
        super.init(frame: frame)
        setupViews()
    }

    private func setupViews() {
        addSubview(nativeAdView)
        nativeAdView.addSubview(iconImageView)
        nativeAdView.addSubview(headlineLabel)
        nativeAdView.addSubview(bodyLabel)
        nativeAdView.addSubview(mediaView)
        nativeAdView.addSubview(callToActionButton)

        // Auto Layout setup
        // ...
    }
}

3. Bind View

Bind ad elements to AdropNativeAdView to display ad data.

func configure(with ad: AdropNativeAd) {
    // Bind each element to AdropNativeAdView
    nativeAdView.setIconView(iconImageView)
    nativeAdView.setHeadLineView(headlineLabel)
    nativeAdView.setBodyView(bodyLabel)
    nativeAdView.setMediaView(mediaView)
    nativeAdView.setCallToActionView(callToActionButton)

    // Advertiser profile (optional)
    if let advertiserLogoView = advertiserLogoImageView,
       let advertiserNameView = advertiserNameLabel {
        nativeAdView.setProfileLogoView(advertiserLogoView)
        nativeAdView.setProfileNameView(advertiserNameView)
    }

    // Set ad data (automatically displayed in bound views)
    nativeAdView.setNativeAd(ad)
}

Binding Methods

Method	Description	Required
`setIconView(_:onClick:)`	Set icon image view. `onClick: ((AdropNativeAd?, UIView) -> Void)? = nil`	Optional
`setHeadLineView(_:onClick:)`	Set title label. `onClick: ((AdropNativeAd?, UIView) -> Void)? = nil`	Optional
`setBodyView(_:)`	Set description label	Optional
`setMediaView(_:)`	Set main image/video view. Required for video creatives — VTR and `onAdVideoStart` / `onAdVideoEnd` only fire when the SDK’s media surface is bound here. See Video Tracking and VTR.	Optional
`setCallToActionView(_:onClick:)`	Set CTA button. `onClick: ((AdropNativeAd?, UIView) -> Void)? = nil`	Optional
`setAdvertiserView(_:onClick:)`	Set advertiser view. `onClick: ((AdropNativeAd?, UIView) -> Void)? = nil`	Optional
`setProfileLogoView(_:onClick:)`	Set advertiser logo image view. `onClick: ((AdropNativeAd?, UIView) -> Void)? = nil`	Optional
`setProfileNameView(_:onClick:)`	Set advertiser name label. `onClick: ((AdropNativeAd?, UIView) -> Void)? = nil`	Optional
`setNativeAd(_:)`	Set ad data	Required

The onClick closure is called when the user taps the bound view. It receives the current AdropNativeAd? instance and the tapped UIView as parameters. If not provided, the default click behavior (opening the destination URL) is used.

To display advertiser profile, you must enable Show Advertiser Profile for the ad unit in Ad Control Console.

4. Handle Delegates

Implement AdropNativeAdDelegate to handle ad events.

extension MyViewController: AdropNativeAdDelegate {
    // Ad received successfully
    func onAdReceived(_ nativeAd: AdropNativeAd) {
        print("Native ad received successfully")

        // Access ad data (properties are non-optional)
        print("Title: \(nativeAd.headline)")
        print("Description: \(nativeAd.body)")
        print("CTA: \(nativeAd.callToAction)")

        // Bind ad to view
        configureNativeAdView(with: nativeAd)
    }

    // Ad receive failed
    func onAdFailedToReceive(_ nativeAd: AdropNativeAd, _ errorCode: AdropErrorCode) {
        print("Native ad failed to receive: \(errorCode)")
    }

    // Ad clicked (optional)
    func onAdClicked(_ nativeAd: AdropNativeAd) {
        print("Native ad clicked")
    }

    // Ad impression (optional)
    func onAdImpression(_ nativeAd: AdropNativeAd) {
        print("Native ad impression")
    }
}

#pragma mark - AdropNativeAdDelegate

// Ad received successfully
- (void)onAdReceived:(AdropNativeAd *)nativeAd {
    NSLog(@"Native ad received successfully");

    // Access ad data
    if (nativeAd.headline) {
        NSLog(@"Title: %@", nativeAd.headline);
    }

    if (nativeAd.body) {
        NSLog(@"Description: %@", nativeAd.body);
    }

    if (nativeAd.callToAction) {
        NSLog(@"CTA: %@", nativeAd.callToAction);
    }

    // Bind ad to view
    [self configureNativeAdViewWith:nativeAd];
}

// Ad receive failed
- (void)onAdFailedToReceive:(AdropNativeAd *)nativeAd :(AdropErrorCode)errorCode {
    NSLog(@"Native ad failed to receive: %ld", (long)errorCode);
}

// Ad clicked (optional)
- (void)onAdClicked:(AdropNativeAd *)nativeAd {
    NSLog(@"Native ad clicked");
}

// Ad impression (optional)
- (void)onAdImpression:(AdropNativeAd *)nativeAd {
    NSLog(@"Native ad impression");
}

Delegate Methods

Method	Required	Description
`onAdReceived(_:)`	Required	Called when ad loads successfully
`onAdFailedToReceive(_:_:)`	Required	Called when ad fails to load
`onAdClicked(_:)`	Optional	Called when user clicks the ad
`onAdImpression(_:)`	Optional	Called when ad is displayed
`onAdVideoStart(_:)`	Optional	Called when a video ad starts playing
`onAdVideoEnd(_:)`	Optional	Called when a video ad finishes playing

Closure Callbacks

As an alternative to delegates, you can use closure-based callbacks.

let nativeAd = AdropNativeAd(unitId: "YOUR_UNIT_ID")

nativeAd.onAdReceived = { ad in
    print("Native ad received")
}

nativeAd.onAdFailedToReceive = { ad, errorCode in
    print("Native ad failed: \(errorCode)")
}

nativeAd.onAdImpression = { ad in
    print("Native ad impression")
}

nativeAd.onAdClicked = { ad in
    print("Native ad clicked")
}

nativeAd.onAdVideoStart = { ad in
    print("Native ad video started")
}

nativeAd.onAdVideoEnd = { ad in
    print("Native ad video ended")
}

If both a delegate and closures are set, both will be called.

Ad Properties

You can access ad data through the AdropNativeAd object.

Basic Properties

// When ad is received successfully
func onAdReceived(_ nativeAd: AdropNativeAd) {
    // Title
    print("Title: \(nativeAd.headline)")

    // Description
    print("Description: \(nativeAd.body)")

    // CTA button text
    print("CTA: \(nativeAd.callToAction)")

    // Main image/video
    print("Media URL: \(nativeAd.asset)")
}

Advertiser Profile

// Advertiser information (profile and its properties are non-optional)
let profile = nativeAd.profile
print("Advertiser logo: \(profile.displayLogo)")
print("Advertiser name: \(profile.displayName)")

// Profile link (optional — links to the advertiser's page)
if let link = profile.link {
    print("Profile link: \(link)")
}

Custom Fields

You can access additional text items set in Ad Control Console.

// Additional text items (extra is non-optional [String: String])
let extra = nativeAd.extra
if !extra.isEmpty {
    // Example: Price information
    if let price = extra["price"] {
        print("Price: \(price)")
    }

    // Example: Discount rate
    if let discount = extra["discount"] {
        print("Discount: \(discount)")
    }

    // Example: Rating
    if let rating = extra["rating"] {
        print("Rating: \(rating)")
    }
}

The extra field uses additional text item IDs defined in the ad unit settings in Ad Control Console as keys.

Property List

Property	Type	Description
`unitId`	`String`	Ad unit ID
`contextId`	`String`	Context ID for contextual targeting
`headline`	`String`	Ad title
`body`	`String`	Ad description
`callToAction`	`String`	CTA button text
`icon`	`String`	Icon image URL
`cover`	`String`	Cover image URL
`asset`	`String`	Main image/video URL
`creative`	`String`	Creative HTML content
`creativeSize`	`CGSize`	Creative content size
`advertiser`	`String`	Advertiser name
`advertiserURL`	`String`	Advertiser URL
`profile`	`AdropNativeAdProfile`	Advertiser profile information
`extra`	`[String: String]`	Additional custom fields
`extraAssets`	`[String: AdropNativeAsset]`	Media items keyed by media ID. See Multi-Media Creatives
`accountTag`	`[String: Any]`	Account-level tag data
`creativeTag`	`[String: Any]`	Creative-level tag data
`destinationURL`	`String?`	Ad destination URL
`txId`	`String`	Transaction ID
`campaignId`	`String`	Campaign ID
`creativeId`	`String`	Creative ID
`browserTarget`	`BrowserTarget?`	How to open URLs on ad click
`isLoaded`	`Bool`	Whether ad is loaded
`isBackfilled`	`Bool`	Whether ad is a backfill ad

AdropNativeAdProfile

Property	Type	Description
`displayLogo`	`String`	Advertiser logo image URL
`displayName`	`String`	Advertiser display name
`link`	`String?`	Link to the advertiser’s page

Custom Click

You can use Custom Click to handle ad click behavior yourself instead of using the default behavior (opening the destination URL).

Setup

let nativeAd = AdropNativeAd(unitId: "YOUR_UNIT_ID")
nativeAd.useCustomClick = true

AdropNativeAd *nativeAd = [[AdropNativeAd alloc] initWithUnitId:@"YOUR_UNIT_ID"];
nativeAd.useCustomClick = YES;

Entire Click Area

Use setIsEntireClick(_:) to make the entire AdropNativeAdView clickable.

nativeAdView.setIsEntireClick(true)

When useCustomClick is true, setIsEntireClick(true) is automatically called in setNativeAd(_:).

Manual Click

Use performClick() to manually trigger a click event.

nativeAdView.performClick()

Open URL

Use open(_:useInAppBrowser:) to open a URL programmatically.

// Open destination URL
nativeAd.open(nativeAd.destinationURL)

// Open in in-app browser
nativeAd.open(nativeAd.destinationURL, useInAppBrowser: true)

Video Tracking and VTR

Adrop measures video metrics for native creatives — including impression-to-completion (VTR), onAdVideoStart, and onAdVideoEnd — only when the video is rendered through the SDK’s media surface (a UIView bound via AdropNativeAdView.setMediaView(_:)). This applies to the ad’s main media (Media 1). For the other media items of a multi-media creative, see Multi-Media Creatives. The AdropNativeAd.asset property returns a URL pointing to the underlying image or video file. It is exposed as supplementary metadata (for example, for thumbnails or your own analytics); it is not intended to drive playback.

Do not feed the asset URL into a custom video player (AVPlayer, AVPlayerViewController, or any third-party player) for a video native ad. When the SDK’s media surface is bypassed:

VTR (Video Through Rate) is not collected for that placement.
onAdVideoStart / onAdVideoEnd callbacks never fire.
Aggregate video performance for the unit will under-report or report zero.

Click (onAdClicked) and impression (onAdImpression) tracking still work because they are wired to the container view, but the video-specific signals are lost.

Recommended pattern

Bind the SDK media surface for every video native:

nativeAdView.setMediaView(mediaView)    // Required for video tracking
nativeAdView.setNativeAd(ad)

[self.nativeAdView setMediaView:self.mediaView];    // Required for video tracking
[self.nativeAdView setNativeAd:ad];

If a placement absolutely requires a custom player and you accept that VTR will not be measured, you can still surface click and impression attribution by keeping the ad bound to AdropNativeAdView. In that case, treat the placement as non-VTR inventory in your internal reporting and avoid mixing it with SDK-measured video performance.

Multi-Media Creatives

Requires the iOS SDK (adrop-ads) 1.16.0 or later. If you use backfill, update adrop-ads-backfill to the same version.

If a native unit has two or more media items, its creatives contain a file for each media item. extraAssets holds every media item of the ad, keyed by the media ID set in the console. Media 1 is always m1, and the other media items use the IDs shown in Media Size on the Ad Unit detail screen, such as m2 and m3.

let media2 = nativeAd.extraAssets["m2"]   // AdropNativeAsset?

AdropNativeAsset *media2 = nativeAd.extraAssets[@"m2"];

Media 1 (m1) is the same media as asset and creative. Keep displaying it with the media view you pass to setMediaView(_:), and draw only the other media items yourself.
extraAssets is empty for creatives of units with a single media item and for backfill ads. Display those ads as usual.
extraAssets is a dictionary, so its order isn’t guaranteed. Look up media items by ID.
If the ad is served in dark mode, image media items are dark mode images too.
To check your layout with a multi-media creative, preview the creative on a test device.

AdropNativeAsset

Property	Type	Description
`id`	`String`	Media ID set in the console (e.g., `m1`, `m2`)
`asset`	`String`	Image or video file URL
`creative`	`String`	HTML that plays a video media item, including its tracking
`cover`	`String?`	Poster image URL of a video. `nil` for images
`type`	`String?`	`"display"` (image) or `"video"`
`isVideo`	`Bool`	Whether the media item is a video

Displaying Media Items

Media	Display	Placement
Image	Load `asset` into a `UIImageView`	Inside `AdropNativeAdView`
Video	Load `creative` into a `WKWebView`	Outside `AdropNativeAdView`, e.g., right below it

Image: Call setIsEntireClick(true) before you register views with setHeadLineView(_:) and the other set…View methods. Media items you draw aren’t views registered with the SDK, so in the default click mode a tap on them isn’t counted as a click. With entire click, if Media 1 is a video, its player controls don’t respond to taps. Don’t load the creative HTML of an image: it doesn’t report clicks to Adrop.
Video: Play the creative HTML, not the asset URL. The HTML contains the video player and its tracking, so video metrics are measured only through it. Place the WKWebView outside AdropNativeAdView: inside, entire click turns every tap, including taps on the player’s controls, into an ad click. Load the HTML when the ad is about to appear on screen, not in advance.
Landing page: When a user taps the video, its HTML reports the click and asks to open the landing page in a new window or in the same window. Handle both in webView(_:createWebViewWith:for:windowFeatures:) and webView(_:decidePolicyFor:decisionHandler:), and open the URL with open(_:useInAppBrowser:) of AdropNativeAd, which follows the creative’s browser setting.

Impressions and Clicks

Impressions, clicks, and video metrics are counted once per ad, not per media item, even when both the SDK and a media item report them.

Event	How it’s counted
Impression	When `AdropNativeAdView` stays at least 50% visible for 0.5 seconds. A video media item also reports the ad’s impression when its video starts playing.
Click inside `AdropNativeAdView`	Counted by the SDK, and `onAdClicked` is called.
Tap on a video media item	Reported by the media item’s HTML. `onAdClicked` isn’t called.
Video playback (Valid Views, Completed Views)	Reported by the media item’s HTML. `onAdVideoStart` and `onAdVideoEnd` aren’t called.

Which taps on a video count as clicks depends on the unit’s video controller setting. With the controller off, every tap on the video is a click. With it on, taps on the play and mute controls aren’t clicks.

Example

This example shows Media 2 (m2) as an image inside AdropNativeAdView, or as a video in a container placed right below AdropNativeAdView. Replace m2 with the ID of your unit’s media item.

import UIKit
import WebKit
import AdropAds

final class MultiMediaNativeAdViewController: UIViewController {
    @IBOutlet private weak var nativeAdView: AdropNativeAdView!
    @IBOutlet private weak var headlineLabel: UILabel!
    @IBOutlet private weak var mediaView: UIView!               // Media 1 (m1): drawn by the SDK
    @IBOutlet private weak var media2ImageView: UIImageView!    // Media 2 (m2) image: inside nativeAdView
    @IBOutlet private weak var media2VideoContainer: UIView!    // Media 2 (m2) video: outside nativeAdView
    @IBOutlet private weak var ctaButton: UIButton!

    private var nativeAd: AdropNativeAd?
    private var videoWebView: WKWebView?

    override func viewDidLoad() {
        super.viewDidLoad()
        nativeAd = AdropNativeAd(unitId: "YOUR_UNIT_ID")
        nativeAd?.delegate = self
        nativeAd?.load()
    }

    private func populate(_ ad: AdropNativeAd) {
        // Count taps on the media items you draw as ad clicks. Call it before registering views
        nativeAdView.setIsEntireClick(true)

        headlineLabel.text = ad.headline
        nativeAdView.setHeadLineView(headlineLabel)
        nativeAdView.setMediaView(mediaView)
        ctaButton.setTitle(ad.callToAction, for: .normal)
        nativeAdView.setCallToActionView(ctaButton)

        // Media 2 (m2). Not in the dictionary for single-media creatives and backfill ads
        if let item = ad.extraAssets["m2"] {
            if item.isVideo {
                showVideo(item)
            } else {
                showImage(item)
            }
        }

        nativeAdView.setNativeAd(ad)
    }

    private func showImage(_ item: AdropNativeAsset) {
        guard let url = URL(string: item.asset) else { return }
        URLSession.shared.dataTask(with: url) { [weak self] data, _, _ in
            guard let data = data, let image = UIImage(data: data) else { return }
            DispatchQueue.main.async { self?.media2ImageView.image = image }
        }.resume()
    }

    private func showVideo(_ item: AdropNativeAsset) {
        let configuration = WKWebViewConfiguration()
        configuration.allowsInlineMediaPlayback = true
        configuration.mediaTypesRequiringUserActionForPlayback = []

        let webView = WKWebView(frame: media2VideoContainer.bounds, configuration: configuration)
        webView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        webView.scrollView.isScrollEnabled = false
        webView.navigationDelegate = self
        webView.uiDelegate = self
        media2VideoContainer.addSubview(webView)
        webView.loadHTMLString(item.creative, baseURL: nil)
        videoWebView = webView
    }

    // Opens the URL as the creative's browser setting specifies
    private func openLandingPage(_ url: URL) {
        nativeAd?.open(url.absoluteString)
    }
}

extension MultiMediaNativeAdViewController: AdropNativeAdDelegate {
    func onAdReceived(_ ad: AdropNativeAd) {
        populate(ad)
    }

    func onAdFailedToReceive(_ ad: AdropNativeAd, _ errorCode: AdropErrorCode) {
        print("Failed to receive: \(errorCode)")
    }
}

// A tap on the video: the HTML has reported the click and asks to open the landing page
extension MultiMediaNativeAdViewController: WKNavigationDelegate, WKUIDelegate {
    // Landing page in a new window
    func webView(_ webView: WKWebView, createWebViewWith configuration: WKWebViewConfiguration,
                 for navigationAction: WKNavigationAction, windowFeatures: WKWindowFeatures) -> WKWebView? {
        if let url = navigationAction.request.url {
            openLandingPage(url)
        }
        return nil
    }

    // Landing page in the same window. The HTML itself (about:blank) loads as usual
    func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction,
                 decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
        guard navigationAction.targetFrame?.isMainFrame == true,
              let url = navigationAction.request.url,
              url.absoluteString != "about:blank" else {
            decisionHandler(.allow)
            return
        }
        openLandingPage(url)
        decisionHandler(.cancel)
    }
}

In a UITableView or UICollectionView, create the media item’s WKWebView when you configure the cell and remove it in prepareForReuse().

Best Practices

Error Handling

Display fallback UI when ad fails to load to maintain user experience.

func onAdFailedToReceive(_ nativeAd: AdropNativeAd, _ errorCode: AdropErrorCode) {
    print("Native ad failed to receive: \(errorCode)")

    // Hide ad area
    nativeAdContainerView.isHidden = true

    // Or display fallback content
    showFallbackContent()
}

Test Unit IDs

Use the following test unit IDs during development and testing.

Ad Type	Test Unit ID
Native (Image)	`PUBLIC_TEST_UNIT_ID_NATIVE`
Native Video (16:9)	`PUBLIC_TEST_UNIT_ID_NATIVE_VIDEO_16_9`
Native Video (9:16)	`PUBLIC_TEST_UNIT_ID_NATIVE_VIDEO_9_16`

// Load test ad
nativeAd = AdropNativeAd(unitId: AdropUnitId.PUBLIC_TEST_UNIT_ID_NATIVE)

Make sure to use actual unit IDs created in Ad Control Console for production deployment.

Batch Loading (loads)

Use AdropNativeAd.loads(...) to request multiple native ads in a single batched call. This is useful for prefetching a pool of ads to insert into feeds, carousels, or paginated lists.

Signature

AdropNativeAd.loads(
    unitId: String,
    contextId: String = "",
    delegate: AdropNativeAdDelegate
)

[AdropNativeAd loadsWithUnitId:@"YOUR_UNIT_ID"
                     contextId:@""
                      delegate:delegate];

Usage

class ViewController: UIViewController {
    private var ads: [AdropNativeAd] = []

    override func viewDidLoad() {
        super.viewDidLoad()
        AdropNativeAd.loads(unitId: "YOUR_UNIT_ID", delegate: self)
    }
}

extension ViewController: AdropNativeAdDelegate {
    // Required single-load callbacks — unused on the batch path.
    func onAdReceived(_ ad: AdropNativeAd) { /* batch path */ }
    func onAdFailedToReceive(_ ad: AdropNativeAd, _ errorCode: AdropErrorCode) {}

    // Batch success — each ad is fully rendered and ready to bind.
    func onAdsReceived(_ ads: [AdropNativeAd]) {
        self.ads = ads
        ads.forEach { ad in
            bind(ad)  // Bind to an AdropNativeAdView.
        }
    }

    // Batch failure
    func onAdsFailedToReceive(_ errorCode: AdropErrorCode) {
        print("Batch load failed: \(errorCode)")
    }

    // Click / impression / video callbacks still fire per instance.
    func onAdClicked(_ ad: AdropNativeAd) {
        print("Native clicked")
    }

    func onAdImpression(_ ad: AdropNativeAd) {
        print("Native impression")
    }
}

@interface ViewController () <AdropNativeAdDelegate>
@property (nonatomic, strong) NSArray<AdropNativeAd *> *ads;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    [AdropNativeAd loadsWithUnitId:@"YOUR_UNIT_ID" contextId:@"" delegate:self];
}

#pragma mark - AdropNativeAdDelegate

- (void)onAdReceived:(AdropNativeAd *)ad { /* batch path */ }
- (void)onAdFailedToReceive:(AdropNativeAd *)ad :(AdropErrorCode)errorCode {}

- (void)onAdsReceived:(NSArray<AdropNativeAd *> *)ads {
    self.ads = ads;
    for (AdropNativeAd *ad in ads) {
        [self bindNativeAd:ad];
    }
}

- (void)onAdsFailedToReceive:(AdropErrorCode)errorCode {
    NSLog(@"Batch load failed: %ld", (long)errorCode);
}

- (void)onAdClicked:(AdropNativeAd *)ad {
    NSLog(@"Native clicked");
}

- (void)onAdImpression:(AdropNativeAd *)ad {
    NSLog(@"Native impression");
}

@end

Delegate Methods

Method	When it fires
`onAdsReceived(_:)`	Batch delivered. Every ad is fully rendered — creative is ready to bind.
`onAdsFailedToReceive(_:)`	Request rejected, network failure, or no fillable ads were returned (`ERROR_CODE_AD_NO_FILL`).
`onAdClicked` / `onAdImpression` / `onAdVideoStart` / `onAdVideoEnd`	Fire on each returned ad just like a single `load()`.

The singular onAdReceived(_:) / onAdFailedToReceive(_:_:) callbacks are not invoked on the loads path. Use onAdsReceived(_:) / onAdsFailedToReceive(_:) as the sole batch signals.

Constants

Int

default:"5"

Upper bound on ads returned from a single loads(...) call.

Constraints

Maximum 5 ads per call. If the server returns more, only the first 5 are delivered.
Backfill is not applied. If no direct ads fill, onAdsFailedToReceive is called with ERROR_CODE_AD_NO_FILL regardless of backfill configuration.
Unlike AdropBanner.loads(...), the native batch waits for every returned ad to finish rendering before firing onAdsReceived(_:), so each instance is fully rendered on delivery.
Hold strong references to the returned ads. If they deallocate before being bound to an AdropNativeAdView, they’re silently dropped.

Backfill Ads

When backfill ads are enabled, backfill ads are automatically loaded when direct ads are unavailable. Use the isBackfilled property to check if the ad is a backfill ad.

class ViewController: UIViewController, AdropNativeAdDelegate {
    private var nativeAd: AdropNativeAd?

    func onAdReceived(_ nativeAd: AdropNativeAd) {
        if nativeAd.isBackfilled {
            print("Backfill ad loaded")
        } else {
            print("Direct ad loaded")
        }
    }

    func onAdFailedToReceive(_ nativeAd: AdropNativeAd, _ errorCode: AdropErrorCode) {
        switch errorCode {
        case .ERROR_CODE_AD_NO_FILL:
            print("No direct ad, requesting backfill...")
        case .ERROR_CODE_AD_BACKFILL_NO_FILL:
            print("No backfill ad available")
            // Hide ad area
        default:
            print("Ad load failed: \(errorCode)")
        }
    }
}

@interface ViewController () <AdropNativeAdDelegate>
@property (nonatomic, strong) AdropNativeAd *nativeAd;
@end

@implementation ViewController

- (void)onAdReceived:(AdropNativeAd *)nativeAd {
    if (nativeAd.isBackfilled) {
        NSLog(@"Backfill ad loaded");
    } else {
        NSLog(@"Direct ad loaded");
    }
}

- (void)onAdFailedToReceive:(AdropNativeAd *)nativeAd :(AdropErrorCode)errorCode {
    if (errorCode == AdropErrorCodeAdNoFill) {
        NSLog(@"No direct ad, requesting backfill...");
    } else if (errorCode == AdropErrorCodeBackfillNoFill) {
        NSLog(@"No backfill ad available");
        // Hide ad area
    } else {
        NSLog(@"Ad load failed: %ld", (long)errorCode);
    }
}

@end

AdChoices Position

For backfill native ads, you can choose which corner displays the AdChoices badge. Set preferredAdChoicesPosition on the AdropNativeAd instance before calling load().

import AdropAds

let nativeAd = AdropNativeAd(unitId: "YOUR_UNIT_ID")
nativeAd.preferredAdChoicesPosition = .bottomRight
nativeAd.load()

@import AdropAds;

AdropNativeAd *nativeAd = [[AdropNativeAd alloc] initWithUnitId:@"YOUR_UNIT_ID"];
nativeAd.preferredAdChoicesPosition = AdropAdChoicesPositionBottomRight;
[nativeAd load];

Value	Description
`.topLeft`	Top-left corner
`.topRight`	Top-right corner (default)
`.bottomLeft`	Bottom-left corner
`.bottomRight`	Bottom-right corner

This setting is a preferred hint for the backfill network and applies only to backfill native ads — direct ads are not affected. The value must be set before load() is called. The backfill network may override the position depending on its policy.

To use backfill ads, add the AdropAds-Backfill dependency. See Getting Started.

Getting Started

SDK installation and initialization

Banner Ads

Implementing banner ads

Interstitial Ads

Implementing interstitial ads

Rewarded Ads

Implementing rewarded ads

​Overview

​Key Features

​Implementation Steps

​1. Load Ad

​Set Context ID

​2. Create Custom View

​UIKit (Storyboard/XIB)

​UIKit (Code)

​3. Bind View

​Binding Methods

​4. Handle Delegates

​Delegate Methods

​Closure Callbacks

​Ad Properties

​Basic Properties

​Advertiser Profile

​Custom Fields

​Property List

​AdropNativeAdProfile

​Custom Click

​Setup

​Entire Click Area

​Manual Click

​Open URL

​Video Tracking and VTR

​Recommended pattern

​Multi-Media Creatives

​AdropNativeAsset

​Displaying Media Items

​Impressions and Clicks

​Example

​Best Practices

​Error Handling

​Test Unit IDs

​Batch Loading (loads)

​Signature

​Usage

​Delegate Methods

​Constants

​Constraints

​Backfill Ads

​AdChoices Position

​Related Documentation

Getting Started

Banner Ads

Interstitial Ads

Rewarded Ads

Overview

Key Features

Implementation Steps

1. Load Ad

Set Context ID

2. Create Custom View

UIKit (Storyboard/XIB)

UIKit (Code)

3. Bind View

Binding Methods

4. Handle Delegates

Delegate Methods

Closure Callbacks

Ad Properties

Basic Properties

Advertiser Profile

Custom Fields

Property List

AdropNativeAdProfile

Custom Click

Setup

Entire Click Area

Manual Click

Open URL

Video Tracking and VTR

Recommended pattern

Multi-Media Creatives

AdropNativeAsset

Displaying Media Items

Impressions and Clicks

Example

Best Practices

Error Handling

Test Unit IDs

Batch Loading (loads)

Signature

Usage

Delegate Methods

Constants

Constraints

Backfill Ads

AdChoices Position

Related Documentation