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: "article_123")

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

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
`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(_:)). 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.

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

​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

Best Practices

Error Handling

Test Unit IDs

Batch Loading (loads)

Signature

Usage

Delegate Methods

Constants

Constraints

Backfill Ads

AdChoices Position

Related Documentation