Introduction
Overview
Integrating with the SDK
Initializing the SDK
Requesting Recommendations
Handling and Displaying Recommendations
Handling Clicks on Recommendations
Navigation to Paid Recommendations
Widget Viewability
Using the Sample Applications
What’s New in Release 2.1
What’s New in Release 2.0
Upgrade From 1.5.* Version


Introduction

Please Note

Following the developer guide instructions is mandatory to ensure app compliance.

Please make sure to follow the entire guide before submitting your app to Outbrain QA.

Please pay special attention to the following steps:

Handling Clicks on Recommendations
Navigation to Paid Recommendations
Widget Viewability

About This Document

This document describes the Outbrain mobile SDK for the iOS platform. It is intended for iOS mobile app developers who want to integrate the Outbrain product into their code. The document describes the main Outbrain interface functions.

Software Requirements

The Outbrain SDK is a framework, and is compatible with iOS 8.0 and upward. In addition, you will need to add AdSupport.framework and SystemConfiguration.framework.

Outbrain Application Review

A finalized build must be sent to Outbrain QA at least one week (5 working days) prior to your anticipated release date. We may request changes which will require additional dev resources and could delay your release. We reserve the right to remove our recommendations or restrict the app from generating Outbrain revenue if required changes are not incorporated prior to release. Builds can be submitted via TestFlight or HockeyApp to test-devices@outbrain.com. Your Account Strategist can provide more details.

Recommendation Display Guidelines and Limitations

The recommendations that Outbrain provides are time-sensitive and should be used within one hour of receiving them. Recommendations are intended for specific users at specific times, and any caching or delay in their presentation will have a negative impact on their performance (and the user experience).
The following limitations and guidelines must be applied to the Outbrain recommendations’ display:

  • Storing/caching recommendations with the intent of delaying their presentation on the page is prohibited.
  • Co-mingling of Outbrain recommendations with other content links within the same container is prohibited, unless mutually agreed upon between the client and Outbrain.
  • Altering or replacing an Outbrain recommendation’s text or image is prohibited.
  • All paid recommendations must be uniquely labeled in a manner that can be reasonably associated with the relevant content, as mutually agreed upon between the client and Outbrain.

Overview

The Outbrain Recommendation User Experience

While a user is viewing a page on your mobile app, you can display content recommendations that may be interesting to him or her. You can recommend both related content within your own app, and 3rd-party content recommendations. You can choose how and when to display the recommendations, whether as a footer, in-feed or other format.

The image below illustrates how a user might view Outbrain recommendations:

ios-outbrain-recommendations

Outbrain Recommendations

The Outbrain Workflow

The Outbrain workflow consists of the following main actions:

  • Request content recommendations related to a specific article or app location.
  • Receive a list of recommendations and display them.
  • When a user clicks on a recommendation, navigate to the recommendation.
Important The Outbrain SDK provides the developer an interface for fetching and receiving recommendations in the form of OBRecommendationResponse which encapsulates the json response from the server. Please note that developers should be responsible for implementing the actual UI of the recommendations in their app. Developers are more than welcome to use Outbrain UI examples which can be found in our Sample Apps: Catalog and Journal.

Working with Recommendation Widgets

A widget is a UI component, implemented within the app. When you design your app, you decide which widgets will display Outbrain recommendations and respond to clicks on them.

For each widget displaying Outbrain recommendations, you must consult with your Outbrain account manager and decide on a suitable configuration. The configuration refers to settings such as:

  • The number of recommendations to be displayed in the widget
  • Whether thumbnail images should be displayed for each recommendation
  • Whether to recommend articles or videos

Once these settings are determined, your account manager assigns a unique ID for each different widget configuration. This is the value you pass in the widgetId parameter when calling fetchRecommendations.

For example, the Outbrain Journal sample app uses 4 widgets, each with a unique widget ID:

  • In-stream – the widget appears within homepage or section front content titles.
  • Drawer – a dynamic widget that appears at the bottom of the display when the user scrolls up, which can be expanded to show additional recommendations.
  • Footer – a widget that’s displayed constantly at the bottom of the page.
  • Interstitial – a widget that appears in between article pages.

These widget types are illustrated in the following images:

ios-fig3-footer-widget
Footer Widget
ios-fig4-inline-widget
In-Stream Widget
ios-fig5-minimized-drawer-widget
Minimized Drawer Widget
ios-fig6-extended-drawer-widget
Extended Drawer Widget

Integrating with the Outbrain SDK


Updating from an older version of the SDK:

Before continuing to the next steps – please remove OutbrainSDK.framework from the project and all its dependencies.


To integrate the Outbrain SDK with your code:

  1. Copy OutbrainSDK.framework to your project dir.

  2. Select your project in the left navigation panel.

    ios-integration-step1

  3. Select the relevant build target.

    ios-integration-step2

  4. Click Build Phases in the top navigation bar.

    ios-integration-step3

  5. Select the ‘Link binary with libraries’ drop down item.

  6. Click ‘+’.

  7. Click ‘Add Other…’ and select the Outbrain.framework file.

  8. Click ‘Add Other…’ and select AdSupport.framework and SystemConfiguration.framework.

  9. Go to target -> Build Settings -> add -all_load to Other Linker Flags

Swift Integration

Outbrain.framework has a built-in Swift Module structure which eliminates the need to deal with the “bridging-header” file. Just drag and drop the framework to the Swift project, import the module with this line of code:
import OutbrainSDK and you’re set!


Initializing the Outbrain SDK

The Outbrain Interface

The Outbrain interface is the main interface to the Outbrain SDK. Your app calls its methods in order to initialize the SDK, request recommendations and report clicks.

Registering App Configuration

You will need to register your app’s Outbrain configuration once during the initialization of your app, before calling any other Outbrain method. You can do this by calling Outbrain’s initializeOutbrainWithPartnerKey method. This method takes a single appKey parameter, which is a string that contains the application key you’ve received from your Outbrain account manager.

Here is an example of how to call initializeOutbrainWithPartnerKey:


[Outbrain initializeOutbrainWithPartnerKey:@"MyPartnerKey"];

Working in Test Mode

While you are developing your app and debugging the integration with Outbrain, you must configure the SDK to work in test mode. This prevents Outbrain from performing operational actions such as reporting and billing, for clicks that were not made by your app’s users.

Here is an example:


[Outbrain setTestMode:YES];

During the development and testing phase, call setTestMode during your app’s initialization, but remember to remove this call before submitting your app to the app store.

Note: Please use test mode only during development and testing phases. Default value is “false”.

Requesting Recommendations

Calling fetchRecommendationsForRequest

When you want to request content recommendations, call Outbrain’s fetchRecommendationsForRequest method. Outbrain will send a response containing a collection of recommendations, based on the request parameters and the Outbrain configuration.

fetchRecommendationsForRequest takes a request parameter. This is an instance of OBRequest, containing the request details (see OBRequest Properties).

In addition, when calling fetchRecommendationsForRequest, you must supply either a callback handler (OBResponseCompletionHandler) or a delegate (OBResponseDelegate), to handle the recommendations response. (See Handling and Displaying Recommendations to learn more about handling the response.)

Here is an example of how to call fetchRecommendationsForRequest:


OBRequest * request = [OBRequest requestWithURL:post.url widgetID:”SDK_1”];

[Outbrain fetchRecommendationsForRequest:request withCallback:^(OBRecommendationResponse *response) {
    if (response.error) {
        //Handle error
    }
    else {
   //Handle success
    }
}

Note: Although the fetchRecommendationsForRequest requests are asynchronous, they are all stored in the same queue, so they are handled in the order in which they were called.

Creating a Recommendation Request

Creating an OBRequest Instance

OBRequest instance is a mandatory argument for fetchRecommendationsForRequest method.
Important – the creation of an OBRequest instance should be done via one of the following 2 “Factory Methods”:


OBRequest * request = [OBRequest requestWithURL:post.url widgetID:”SDK_1”];
OBRequest * request = [OBRequest requestWithURL:post.url widgetID:”SDK_1” widgetIndex:1];


(DO NOT create an OBRequest instance directly via [[OBRequest alloc] init])

Set the following properties:

  1. url (mandatory) – the URL of the page for which you’re requesting recommendations. (See Request URL for more details.)
  2. widgetId (mandatory) – the widget ID (see Request Widget ID for more details).
  3. widgetIndex (optional) – the widget index, required if there is more than one widget on the same app page (see Request Widget Index for more details).


Request URL

There are two types of URLs for which you can request recommendations:

  • An article or video page
  • A home page or section front

In the case of a home page or section front, please consult with your Outbrain account manager about how to construct the URL.

Note: Each page’s URL must be unique to the page and consistent (i.e. the same URL must be sent every time recommendations are requested for the same page.)

Request Widget ID

There may be one or more locations in your app where you want to display content recommendations. In addition, you may need to display recommendations in several different widgets on the same page.

Widget IDs are pre-assigned by your account manager after you define your display requirements for the specific widget. The widget ID maps to settings related to the widget’s display, the number of recommendations returned, etc.

Note: Before using the Outbrain SDK, make sure you have widget IDs assigned to all the widgets in which you’ll need to display recommendations.

For example, the Journal sample app uses 4 different widget IDs:

  • ID “SDK_1” for the in-stream homepage widget.
  • ID “SDK_2” for the interstitial widget.
  • IDs “SDK_3” and “SDK_4” for footer and drawer widgets on article pages.

Request “Widget Index”

The widget index is a numeric, zero-based value assigned sequentially to all widgets on the same page. If you plan to use (or already using) more than one widget on a single page on your Mobile app – you’ll have to implement the fetching of the recommendations in a specific order according to the guidelines below:

As a side note, it’s important to note that on Mobile apps there is no “real page”, so the meaning of a “page” in this context is a “screen” or a “page” in which 2 widgets or more are shown to the user.

For example, if you have 3 widgets on a page, you’ll assign the indexes 0, 1 and 2 to these widgets. The widget index is used to differentiate between widgets on the same page, so as not to duplicate recommendations sent to different widgets. Widgets on the same page may be of different types (e.g. footer and drawer), or may be multiple instances of the same type (e.g. multiple in-feed), that should display different recommendations.

Guidelines for Fetching Recommendations Multiple Times in a Single Page

Note: This section is relevant only if you plan to have more than one UI Widget on the same screen.
  1. Please make sure that you set the “widget index” variable for each request, i.e. the first request should be sent with idx=0, the second with idx=1 and so on.

  2. The second call for “fetchRecommandations” should be executed from the callback (success or failure) of the first request. The reason we ask our developers to do this is as follows: the response of the first request contains a token from the server that should be sent together with the second request. This is all done “behind the scene” by the SDK, however in order for this to work the SDK has to wait for the response of the first call. Meaning, you, the developer, have to make sure this logic works well within your app.

The code is from Outbrain “Journal” sample app:

- (void)delayedContentLoad
{
    if(_outbrainLoaded || _loadingOutbrain) return;

    OBRequest * request = [OBRequest requestWithURL:self.post.url widgetID:OBDemoWidgetID2];
    [Outbrain fetchRecommendationsForRequest:request withDelegate:self];
}

#pragma mark - OBResponseDelegate methods
- (void)outbrainDidReceiveResponseWithSuccess:(OBRecommendationResponse *)response
{
    _outbrainLoaded = YES;
    _loadingOutbrain = NO;

    // If there are no recommendations (shouldn't happen often).  Then we
    // just don't show anything
    if(response.recommendations.count == 0)
    {
        // .... code for handling this situation
        return;
    }

    // If "true" we received the response of the first "fetch" request
    if (response.request.widgetIndex == 0) {
        self.outbrainClassicView.recommendationResponse = response;

        //TODO implement UI for first set of recommendations
        // ....
        // ....

        OBRequest * secondRequest = [OBRequest requestWithURL:self.post.url
                                                     widgetID:OBDemoWidgetID2
                                                  widgetIndex:1];           
        [Outbrain fetchRecommendationsForRequest:secondRequest withDelegate:self];

    }
    else { // This is the response of the second "fetch" request
        self.outbrainHoverView.recommendationResponse = response;
        //TODO implement UI for second set of recommendations
        // ....
        // ....
    }
}

- (void)outbrainResponseDidFail:(NSError *)response
{
    UIAlertView * alert = [[UIAlertView alloc] initWithTitle:response.domain message:response.userInfo[NSLocalizedDescriptionKey] delegate:nil cancelButtonTitle:nil otherButtonTitles:@"OK", nil];
    [alert show];
}

Please note the following:

  1. The flow starts at delayedContentLoad() – there we fetch recommendations for OBDemoWidgetID2.

  2. On the “success” callback we call the second widget OBDemoWidgetID3 (OBDemoWidgetID3) and we set idx=1


Handling and Displaying Recommendations

Handling the OBRecommendationResponse

After a successful call to fetchRecommendationsForRequest, Outbrain calls your callback or delegate method, providing an OBRecommendationResponse object. Using this object, you can iterate over the list of recommendations and display them in your app.

Here is an example implementation of an OBResponseDelegate’s outbrainDidReceiveResponseWithSuccess method:


(void)outbrainDidReceiveResponseWithSuccess:(OBRecommendationResponse *)response
{
    int numRecs = response.recommendations.count;
    for (int i = 0; i < numRecs; i++) {
        OBRecommendation *rec = [response.recommendations objectAtIndex:i];
                    [self addRecToMyWidgetWithContent:rec.content,    // recommendation title
                               thumbnail:rec.image]; // recommendation image
        }
}

Displaying a Recommendation

Each OBRecommendation object contained within the OBRecommendationResponse has the following properties:

  • content - the recommendation's title.
  • image – a thumbnail image (OBImage object) related to the recommendation. This property is optional and is included only if the widget is configured to display images.
  • source – the name of the recommendation's source (publisher). For paid recommendations, this is the site name, and for organic recommendations, this is the section name.
  • paidLink – indicates whether this a paid or organic recommendation.
  • video – indicates whether the recommendation points to an article containing a video clip.

    // Example: displaying a specific recommendation
    // getting the recommendation
    OBRecommendation rec = recResponse.get(index);
    // getting the title
    String title = rec.content;
    // .... populate the relevant UI component with the title
    
    // getting the source
    String source = rec.source;
    // .... populate the relevant UI component with the source
    
    // getting image URL
    if (rec.thumbnail != nil) {
       String imageURL = rec.thumbnail.url;
       // .... populate the relevant UI component with the image
    }

    // handling paid VS organic recommendation
    If ([rec isPaidLink]) {
       //....Show disclaimer, add paid icon, etc…
    }
    // handling video VS article
    if ([rec isVideo]) {
       //Add video icon on recommendation
    }

ios-fig10

Recommendation Display Components

Displaying Thumbnail Images

The thumbnail image is defined by the OBImage object returned within OBRecommendation. It contains the following properties:

  • width – the image width in pixels
  • height – the image height in pixels
  • url – a URL pointing to the image file. Use the URL to render the thumbnail image (see examples in the Outbrain sample apps).

The image width and height values are those agreed upon and determined by the widget ID.

Outbrain Widget Labeling

Any widget displaying Outbrain recommendations must be labeled with a header that is mutually agreed upon between the client and Outbrain.

To comply with Outbrain labeling guidelines:
  1. Add the widget title text agreed upon with Outbrain (e.g. “Recommended to you”).
Note: For Viewability you'll be using OBLabel for displaying the widget title. Read more about this in widget viewability.
  1. Choose one of the Outbrain logo images from the Outbrain-Resources folder, and add a clickable Outbrain logo to your widget, that opens the following link:
    <a href=”http://www.outbrain.com/what-is/default/en-mobile”>privacy policy</a>

ios-fig8-labeled-recommendations

Labeled Outbrain Recommendations

See Recommendation Display Guidelines and Limitations for additional instructions about how to display Outbrain recommendations.


Handling Clicks on Recommendations


Navigating to the Recommendation

Note: The best way to understand the new logic is by looking at our Journal Sample App, specifically look at file PostsSwipeCV.m - you will find a good example for the implementation in method:

- (void)widgetView:(UIView *)widgetView tappedRecommendation:(OBRecommendation *)recommendation

When a user clicks on a recommendation, navigate to it as follows:

1) Check if it's a paid rec by calling recommendation.isPaidLink

For example:

if (recommendation.isPaidLink)
{
    [self handlePaidRecommendation:recommendation];
}
else { // Organic
    [self handleOrganicRecommendation:recommendation];
}

2) Get the URL of the recommendation by:

// rec is an OBRecommendation object returned in OBRecommendationsResponse
NSURL * url = [Outbrain getUrl: rec];


Note: For paid recommendations, the returned URL is in paid.outbrain.com re-direct format. For organic recommendations the returned URL is in the standard (original) format. Developers should open the url "as is", i.e. without any manipulation such as escaping or decoding.

3) Navigate to the Recommendation


Navigate to Organic Recommendations

Navigate to the organic content using your app’s standard navigation mechanism. You can find an example in the Journal sample app.


Navigate to Paid Recommendations

As you can see in the flow below, there are two options for opening Outbrain paid recommendations

Option 1: Use SFSafariViewController for all paid recommendations

OR

Option 2: Use Outbrain OBWebView/OBWKWebview classes (extends UIWebView/WKWebViewand) and SFSafariViewController, based on the SDK response for each paid recommendation.

If you are using UIWebView or WKWebView, Please make sure to follow Apple ATS guidelines for displaying web content: https://developer.apple.com/library/content/documentation/General/Reference/InfoPlistKeyReference/Articles/CocoaKeys.html#//apple_ref/doc/uid/TP40009251-SW35

Using SFSafariViewController for all paid recommendations

In case you are opening all paid recommendations with SFSafariViewController (option 1), please see the code example below as a reference.

- (void) openUrlInSafariVC:(NSURL *)url {
    if (SYSTEM_VERSION_LESS_THAN(@"9.0")) {
        [[UIApplication sharedApplication] openURL:url];
        
    }
    else {
        SFSafariViewController *sf = [[SFSafariViewController alloc] initWithURL:url];
        [self.navigationController presentViewController:sf animated:YES completion:nil];
    }
}

Using OBWebView/OBWKWebview and SFSafariViewController

If you choose to use Outbrain OBWebView/OBWKWebview classes (extends UIWebView/WKWebViewand) and SFSafariViewController, based on the SDK response for each paid recommendation (option 2), please follow the next steps.

Please make sure to follow Apple ATS guidelines for displaying web content: https://developer.apple.com/library/content/documentation/General/Reference/InfoPlistKeyReference/Articles/CocoaKeys.html#//apple_ref/doc/uid/TP40009251-SW35

First, check if the paid recommendation should be opened in SFSafariViewController or with OBWebView/OBWKWebview by calling

if (rec.shouldOpenInSafariViewController) {
    // Open the URL in SFSafariViewController
} else {            
    // Open the URL in OBWebView / OBWKWebView
}


Open in SFSafariViewController

Following the above example, you should be able to open a paid recommendation in SFSafariViewController. Please use the code sample below if needed:

- (void) openUrlInSafariVC:(NSURL *)url {
    if (SYSTEM_VERSION_LESS_THAN(@"9.0")) {
        [[UIApplication sharedApplication] openURL:url];
        
    }
    else {
        SFSafariViewController *sf = [[SFSafariViewController alloc] initWithURL:url];
        [self.navigationController presentViewController:sf animated:YES completion:nil];
    }
}


Open in OBWebView / OBWKWebview

Please note:

This section is applicable only if you choose option two (see above)

Please make sure to follow Apple ATS guidelines for displaying web content: https://developer.apple.com/library/content/documentation/General/Reference/InfoPlistKeyReference/Articles/CocoaKeys.html#//apple_ref/doc/uid/TP40009251-SW35

When if (rec.shouldOpenInSafariViewController) is "false" - The URL of the paid recommendation should be opened inside in-app Webview of type **OBWebView or ***OBWKWebview (developers can use the Class directly or inherit from it for custom appearance / behavior).

** OBWebView - inherits from the base UIWebView Class with the addition of specific Outbrain business logic.

*** OBWKWebview - inherits from the base WKWebView Class with the addition of specific Outbrain business logic. If you choose to use this Class don't forget to #import <WebKit/WebKit.h>



iOS custom webview


Note: The best way to understand how to implement OBWebView is by looking at our Journal Sample App, specifically look at file OBRecommendationWebVC.m - you will find a good example for the implementation there.
Swift Code Sample: See how simple it is to integrate Outbrain Custom Webviews. Check our OutbrainDemoSwift Sample App, specifically look at file WebBrowserViewController.swift

Widget Viewability

Overview

The latest feature of Outbrain Widget Viewability measurement allows Outbrain to optimize the recommendations served for the application audience, hence support a better user experience and app performance.

Widget Viewability measures if the app user has seen the widget on the device screen.

Note: The best way to understand how to implement Viewability is by looking at our Journal Sample App, specifically look at file OBClassicRecommendationsView.m - you will find a good example for the implementation in method:

collectionView:viewForSupplementaryElementOfKind:atIndexPath:
Swift Sample: Please look at our OutbrainDemoSwift Sample App, specifically look at file ArticleTableViewController.swift - you will find a good example for the implementation in method:

loadPageContentOnScreen()


Widget Viewability for iOS SDK

Widget Viewability is implemented via OBLabel (iOS). Which is a child of the native base Class UILabel with the addition of reporting Viewability stats to Outbrain back-end.

iOS OBLabel

Note: You can either use OBLabel directly or inherit from it for additional customization.



We ask our developers to use OBLabel for the text in the Header of the Outbrain widget. See example below:

ios_viewability_example


Important Concept - registerOBLabel() method

The most important step in the Widget Viewability implementation (after the view creation of course) is to register the OBLabel with the corresponding widgetID and URL of the page.

+ (void) registerOBLabel:(OBLabel *)label withWidgetId:(NSString *)widgetId andUrl:(NSString *)url;

1) Simple Case: You should call registerOBLabel:withWidgetId:andUrl only once, right after the creation of the view, with the corresponding widgetID and URL of the page (see code example here).

2) Complex Case: For re-usable views (ViewPager, TableViewCells, etc, etc), you have to make sure that every time the re-usable view is updated with new content (i.e. new url) you should call registerOBLabel:withWidgetId:andUrl method with the new url and the corresponding widgetId.

For Example: A News app which shows articles in a ViewPager and an Outbrain widget is shown at the footer of each article page.

Users can swipe left\right between articles while the app is re-using of the article pages, when the user swipes 5 times to the right, only the content of the page is changing according to the current index in the Pageview, but the views are re-used.

In this case, the developer is responsible to call registerOBLabel:withWidgetId:andUrl whenever a new URL is loaded to the page.


Please Note in case you have more than one Outbrain Widget on the same screen, you’ll have to make sure to register each OBLabel with the URL of the screen (same between all widgets) and Widget_ID (different between all widgets).

How to Integrate Widget Viewability Feature?

There are 2 ways to create and use OBLabel (like any other native View on iOS):

  • Via Xcode Interface Builder
  • Via Code

Xcode Interface Builder

1) Open the Storyboard or XIB file which contains the Outbrain Widget.

2) Click on the ViewController or Parent View where the Outbrain Widget (including the Header) is implemented.

3) Find the UILabel which contains the text in the Header, usually the text is something like “Recommended to You”.

4) Replace the Class of the element from UITextView or UILabel to OBLabel

5) See example:

viewability_xib_example_ios

Important: In code, register the OBLabel instance and its corresponding widgetID and URL by calling:

[Outbrain registerOBLabel:self.obLabel withWidgetId:widgetId andUrl:url];


Implementation via Code

1) Create a new instance of OBLabel by calling:

OBLabel *headerLabel = [[OBLabel alloc] init];

2) Important: call Register() with the OBLabel instance and its corresponding widgetID and url by calling:

[Outbrain registerOBLabel:headerLabel withWidgetId:self.widgetId andUrl:self.url];

3) That’s it, from here you’re good to go.


Using the Sample Applications

The Outbrain SDK includes two sample applications that demonstrate how to use the SDK: the Catalog application and the Journal application. Both are located under the Samples folder of your SDK installationapplications are targets within the OutbrainDemo project. The following sections describe these applications.

The Catalog Sample Application

To use the Catalog sample application, open the OutbrainDemo project and select the Catalog target.
This application contains a collection of recommendation display layouts, which you can use to get an idea of how to present recommendations in your own app, or even copy the layout code as is.
Catalog first displays a menu of available layouts. Tapping on a layout name displays recommendations in the chosen layout.

ios-fig12-catalog-app-menu
Catalog Application Menu
ios-fig13-catalog-article-image-layout
Catalog Article with Images Layout

The Journal Sample Application

To use the Journal sample application, open the OutbrainDemo project and select the Journal target.
This application shows a page of articles, with Outbrain recommendations interspersed in between the original articles. The user can swipe the recommendations to the left or right, to see additional recommendations.

ios-fig14-journal-app

Journal Application

What's New in Release 2.1

2.1.1: Minor bug fix (memory leak)

2.1:

1) Apple ATS support:

  • SDK communication with Outbrain backend services is done with HTTPS

  • Please note: For paid recommendations, Outbrain redirect service (paid.outbrain.com) will redirect to an HTTP page in most cases (provided by Outbrain marketers).

  • If you are using UIWebView or WKWebView, Please make sure to follow Apple ATS guidelines for displaying web content: https://developer.apple.com/library/content/documentation/General/Reference/InfoPlistKeyReference/Articles/CocoaKeys.html#//apple_ref/doc/uid/TP40009251-SW35

2) SDK and sample apps are created with Xcode 8

What's New in Release 2.0

New Features

1) Updated paid recommendation navigation flow for better performance and analytics:

Open Paid Recommendation via Custom WebView (OBWebView or OBWKWebview) or SFSafariViewController, see here

2) Widget Viewability support, see here

3) New URL retrivel method:

+ (NSURL *)getUrl:(OBRecommendation *)recommendation;


Removed (see upgrade instructions)

Init Outbrain

+ (void)initializeOutbrainWithConfigFile:(NSString *)pathToFile;

Get URL of a Recommendation

+ (NSURL *)getOriginalContentURLAndRegisterClickForRecommendation:(OBRecommendation *)recommendation;


Stability and performance

  • All network calls are dones via NSURLSession instead of NSURLConnection


Upgrade From 1.5.* Version

Please Note The following steps (1-5) are mandatory steps to ensure app compliance. Please make sure to follow the steps before submitting your app to Outbrain QA

1) In Xcode Settings: Go to target -> Build Settings -> add -all_load to Other Linker Flags

2) Make sure to use the following init method:

+ (void)initializeOutbrainWithPartnerKey:(NSString *)partnerKey;

3) Use

+ (NSURL *)getUrl:(OBRecommendation *)recommendation;

instead of

+ (NSURL *)getOriginalContentURLAndRegisterClickForRecommendation:(OBRecommendation *)recommendation;

4) Implement the updated instructions for handling clicks on paid recommendations as described here

5) Implement the new Widget Viewability feature as described here

What's New in Release 1.5.2

1) Improved registration method (no need for config file) - registration to Outbrain can be done with:

+ (void)initializeOutbrainWithPartnerKey:(NSString *)partnerKey;

2) Deprecated functions:

Class OBRequest {
    @property (nonatomic, copy) NSString *mobileId;
    @property (nonatomic, copy) NSString *source;
}

3) REMOVED:

homePageRequest

The SDK automatically handle homepage requests, there is no need to set \ get this parameter manually.

4) Stability and performance

  • SDK was built with iOS 9, Xcode 7
  • Minimum SDK support is iOS 7.0
  • SDK size optimization - current size 1.5MB (was 6MB)

5) BITCODE support - read about Apple App Thinning for more details

6) Improve Sample Apps code

  • iOS 9 support
  • Supporting all iPhone sizes
  • Improved performance
  • Bug fixes

7) Swift Support - built-in Swift Module structure which eliminates the need to deal with the bridging header file. Just drag and drop the framework to the Swift project, use:
import OutbrainSDK – and that’s it!

8) Swift Sample App – we prepared a sample app in Swift so you’ll be able to quickly take references from our code and integrate in your project.