Search for Kindle Apps Ad Solution

Games2Win always believed their ad revenue from their Kindle Apps could do better.  Just like many mobile game developers relying on advertising for a significant portion of its revenue, they continually evaluate the performance of its ad networks.

Amazon Mobile Ads API Trial

Games2Win decided to try the Amazon Mobile Ads API after its release.  The plan was to test its performance in one of their mid-size Kindle Fire apps, Eventually, they would expand the Amazon Mobile Ads API to other flagship games such as Parking Frenzy and Dating Frenzy if the results proved positive.

Strong Performance and Broad Deployment on Android

Games2Win found a good reason to accelerate adoption of the Amazon Mobile Ads API across their catalog. Amazon delivered 733% better than any other ad network Games2Win tested with a $1.25 eCPM.*  Dating Frenzy achieved similar results, proving the initial success was no fluke. Parking Frenzy rose to $1.85 eCPM, and Perfect Date hit an all-time high of $2.87 eCPM.  Games2Win was pleasantly surprised, to say the least.

“The $2.87 eCPM we saw through Amazon far exceeded our expectation. Now we’re racing to get Amazon integrated in all of our apps across all Android stores.”

—Mahesh Khambadkone, Co-Founder of Games2Win

Recipe for Success

Games2Win shares the following best practices with other developers based on their experience.

Incorporate ads in to the app early in the design phase. “Integrate the ads into the game early on.  Don't rely on using the pre-provided demo app to prove that ads work,” says Kamalakannan Jothi, Head of Games Technology.  “Depending on the platform you are developing on, understand how its plugins are integrated.  This makes any debugging much easier.”  Games2Win creates its games using Adobe AIR and Unity3D.

Jothi also recommends calling the Amazon Mobile Ad Network first to take advantage of the high eCPM then using a mediation layer to call other third-party ad networks afterwards.  Take advantage of open source and commercial plug-ins when possible to avoid having to roll your own.

About Games2Win
Games2win (g2w) is a casual games company that has clocked 35 million downloads across all mobile stores in just one year.
http://www.games2win.com/en/
India

* Performance may vary by app.

There are several ways to customize the behavior of Amazon Mobile Ads, such as targeting certain user segments or changing how ad size is determined, among others. How ads interact with your app’s layout, for example, is an area worth exploring, since there are several options to choose from and the one you select is largely a matter of personal taste.

Several posts on this blog and the technical documentation are available to help you get started with Mobile Ads in as little as five minutes, so I’ll assume that you have already:

1)      Set up an account on Amazon’s Mobile App Distribution Portal, including your tax and payment information,

2)      Downloaded the Mobile Ads API, added it to your project, and updated your manifest, and

3)      Initialized Mobile Ads in your app using its Application Key (available on the portal).

With basic integration out of the way, we can talk about the difference between programmatic and XML layout configuration. Configuring your ads in code allows for dynamic changes in response to events (for example), while XML resources consolidate layout data in a centralized, easy-to-read format. Both will require an AdLayout object, which we can define as a member object in our Android Activity:

public class MainActivity extends Activity {
   // Hold a reference to the AdLayout we create.
   protected AdLayout adView;

    . . .
}

Defining Your Ad Layout in Code

If you want to lay out your ads programmatically, you take responsibility for manually instantiating the AdLayout (called adView, in the example above) and inserting it into your view hierarchy, usually in the onCreate() method.  For example:

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);

       // Initialize Mobile Ads with this app’s secret key.
       AdRegistration.setAppKey("my_secret_application_key");

        // Instantiate the AdLayout object and get a pointer to the layout where
       // it will live (in this case, the app’s main layout). Note that we also
       // set the ad size explicitly to 600 x 90 pixels.
       this.adView = new AdLayout(this, AdSize.SIZE_600x90);
       LinearLayout layout = (LinearLayout)findViewById(R.id.activity_main);
       layout.addView(this.adView);

        // Asynchronous task to retrieve an ad.
       this.adView.loadAd(new AdTargetingOptions());

    }

Note that we’re explicitly setting the size of the ad we want Mobile Ads to supply to us. In the example above, the second parameter to the AdLayout constructor effectively sets layout_width and layout_height to 600 and 90, respectively. If we omit it, we direct Mobile Ads to select an appropriate ad size on its own. Here’s what the constructor call looks like without the size parameter:

        // No explicit size requested enables Auto Ad Size mode.      
       this.adView = new AdLayout(this);

We recommend that this auto size selection mode be used with ads that span the entire screen width, so it’s good practice to make the target layout as wide as the screen. (This isn’t required, though.) MATCH_PARENT can then be used to ensure the ad fills the entire width.  Optionally, WRAP_CONTENT can be used to force the ad to scale as appropriate to fill the entire AdLayout.  Modifying onCreate() to select the ad size automatically, we might obtain something like this:

   @Override
   protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);

        // Initialize Mobile Ads with this app’s secret key.
       AdRegistration.setAppKey("my_secret_application_key");

        // No explicit size requested enables Auto Ad Size mode.      
       this.adView = new AdLayout(this);
       LinearLayout layout = (LinearLayout)findViewById(R.id.activity_main);

        // Ensure the ad scales to fill the screen width.
       LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(
           LinearLayout.LayoutParams.MATCH_PARENT,
           LinearLayout.LayoutParams.WRAP_CONTENT);
       layout.addView(this.adView, lp);

        // Asynchronous task to retrieve an ad.
       this.adView.loadAd(new AdTargetingOptions());

    }

Defining Your Ad Layout in XML

Besides choosing to specify the ad size ourselves (or letting Mobile Ads do it for us), we also have options when it comes to how we define the AdLayout. We can do it in code, as shown above, or move the definition to our resource files, separating implementation from interface. We’ll still use our adView member to hold the object reference, but instantiation becomes a simple look-up instead of a constructor call. We don’t have to modify the view hierarchy, either, since it’s implicit in the structure of our XML resource:

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);

        // Initialize Mobile Ads with this app’s secret key.
       AdRegistration.setAppKey("my_secret_application_key");

        // Just look up the AdLayout and go.
        this.adView = (AdLayout)findViewById(R.id.adView);
        this.adView.loadAd(new AdTargetingOptions());

    }

This approach requires a corresponding change to the activity_main.xml file, of course, since it’s providing the content view for our Activity in this example (see the setContentView() call, above). This is a good thing, though, since changes to the layout will now be made in that resource file instead of in code.

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
      xmlns:Amazon="http://schemas.android.com/apk/lib/com.amazon.device.ads"
      android:id="@+id/activity_main"
      android:layout_width="match_parent"
      android:layout_height="match_parent"
      android:gravity="top|center_horizontal"
      android:orientation="vertical">

      <com.amazon.device.ads.AdLayout
       android:id="@+id/adView"
       android:layout_width="320dp"
       android:layout_height="50dp"
       Amazon:adSize="320x50"/>

    </LinearLayout>

This minimal example shows how a 320 x 50 AdLayout would be defined in an XML resource file. Note that we have to define the Amazon namespace first, which we do by adding another xmlns attribute to the root element of the document.

Auto Ad Size is available to us when defining the AdLayout in XML, just as it is when we define it programmatically. Like we did in the code version, we simply omit the explicit size parameter and replace the hard-coded dimensions to match the parent width and wrap the content height:

      . . .
     <com.amazon.device.ads.AdLayout
       android:id="@+id/adView"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"/>

Once again, Mobile Ads will select an ad size appropriate to the pixel density and width of our screen, then scale the ad image as appropriate to fill the space.

Final Thoughts

Regardless of how we define our AdLayout, we must clean up after ourselves when our Activity is destroyed. This just means we need to explicitly dispose of the object when appropriate:

   @Override
   public void onDestroy() {
       super.onDestroy();
       this.adView.destroy();
   }

It’s also worth repeating that an AdLayout object may load, at most, one ad at a time. (There’s no reason you can’t instantiate more than one AdLayout, though, if you’re keen on showing multiple ads at once.) Defining multiple AdLayout objects in code or XML is straightforward and follows the patterns described above.

For more information about handling layouts and additional tips and best practices for Mobile Ads in general, see Understanding the Mobile Ads API in the online documentation.

Note: Effective 08-26-2015 Free App of the Day (FAD) has been replaced with Amazon Underground.

Amazon Mobile Ads API developer, Games2Win, Increases Earnings by 733% on Kindle Apps with eCPM up to $2.87

"The $2.87 eCPM we saw through Amazon far exceeded our expectations. Now we're racing to get Amazon integrated in all of our apps across all Android stores," says Mahesh Khambadkone, Co-Founder of Games2Win. See how Games2Win uses the Amazon Mobile Ads API to increase their earning by 733% on their Kindle Fire apps with eCPM up to $2.87. Click here for more monetization tips.

As I was reviewing our catalog of blog posts and thinking about blog posts we should write in the coming weeks, I was impressed by the number of ways Amazon helps developers monetize their apps. I thought it would be a good idea to recap those here!

To learn more about the items above, please continue reading below.

Reach

No development effort is required to take advantage of Amazon’s reach.

•      In nearly 200 countries - The Amazon Appstore is available in the hottest app-buying markets in the world.

•      The only store on Fire - The Amazon Appstore is the only app store on Kindle Fire, the best selling Android Tablet worldwide.

Programs and Promotions

No development effort is required to take advantage of our programs, but you do need to sign up for Free App of the Day.

•      Amazon Coins – a virtual currency that users can get for up to a 10% discount, but still pay the developer the same as actual currency

•      Free App of the Day – Just tick the checkbox when submitting your app and you will be considered for the program.

•      Test Drive – By removing friction for customers who want to try apps, the more apps they will try. Those customers are more likely to find apps they are excited to download.  In this way, Test Drive helps customers understand the value of premium apps and helps drive downloads of freemium apps. Since Test Drive launched, it has been enabled on over 16,000 apps.

•      Personalized Recommendations – Increases the chance that your app will be seen by its most likely buyers.

Revenue Producing APIs

Development is required to make money with our APIs, and we’re working hard to make that effort as easy as possible. These are the APIs I’d like to talk about now.

In-App Purchasing (IAP): If you wish to sell digital assets like game currency or access to features or data within your app, the In-App Purchase (IAP) API has three good options for you:

Selling lasting items: If you have an app in which users need ownership of something durable, say, a new sword for their dungeon crawler character, you would use an IAP entitlement transaction. If you have a productivity app that has a set of advanced features you want to sell at a premium, you don’t need to have a free and a paid version of your app in the appstore; you need only one free version with an IAP entitlement inside to purchase access to the advanced features.

Delivering content or value over time: You could even collect $0.99 every month for the advanced features of your app if your users would rather subscribe to advanced features. For this, you would use the subscription IAP item. Access to advanced features would be available while the subscription was active, and inactive otherwise. You can also use subscription IAP items so a user can subscribe to a stream of entitled items like magazines. As long as you are subscribed, you get issues that you become entitled to even after your subscription ends.

Consumable items: If you have an app in which the user spends game currency, you would want a consumable IAP transaction. In a consumable IAP transaction, users get a set quantity of something, usually power-ups, hints, un-do actions or coins that they consume during play. Once they are out, they can buy more.

Mobile Ads: If you want to collect revenue by displaying ads on your site, then the Mobile Ads service is for you. You can display a traditional banner advertisement (anywhere on your screen above the fold), you can display expandable interactive ads, and you can even pop up large views displaying our largest ads for an interstitial ad experience.

Mobile Associates: If your app is a natural compliment for a physical good, then you will like the Mobile Associates program and API. If, for example, you have a GPS phone app, you could probably earn some revenue share income by offering hiking or outdoor-related items from the Amazon.com store to your customers. Your revenue-share in the Mobile Associates program varies depending on the category of the item sold, but you can use this API set to sell one item and never have the user exit the context of your app, or you can collect a rev-share on an entire shopping-cart of items that a user will purchase in the Amazon.com UI.

Other APIs

Okay, these APIs don’t generate revenue directly, but they are so important to generating revenue I had to find a way to get them in this post.

A|B Testing: Now you can test to see what makes more money in the real world.

Have you ever wondered if placing an In-App-Purchase dialog box at the beginning of a level or at the end of a level would result in more revenue? Now you can find out which is actually best with real users. You can test any set of conditions and successes to find the combination that is most profitable for you. And you can change the variables and the mix without having to re-submit your app. (works on all Android app stores).

GameCircle: The current version of GameCircle is free, and provides your users with saved game syncing, achievements, and leaderboards that work on most Android apps sold from any Android marketplace. The cross-store capability is nice, but the big take-away here is that games with GameCircle make 83% more average revenue per user than games that don’t.

So it turns out that there are a lot of things Amazon is doing to help you make the most from your app (documentation for the APIs can be found in our dev portal here) It’s easy to start selling your apps on Amazon. Just click here to create a free account today.

In previous posts, we’ve touched on the eCPM benefits and ease of implementation of the Amazon Mobile Ads service. But easy to implement doesn’t mean inflexible. We’d like to cover some easy ways you can do Ad Targeting.

In addition to being able to specify the ad unit size, there are a number of targeting options you can include in the request that's sent to the Amazon Mobile Ad Network.

The properties you can send to get more accurately targeted ads are:

For example, to get ads that are better suited to 35 year-old males in the use’s specific region, do the following:

public void onCreate(Bundle savedInstanceState) {
   ...
    AdTargetingOptions adOptions = new AdTargetingOptions();
    adOptions.enableGeoLocation(true);
    adOptions.setGender(AdTargetingOptions.Gender.MALE);
    adOptions.setAge(35);

}

Easy, isn’t it.

You can also customize the floor price for the ads you receive. For example, if you want to get ads that will pay no less than $0.85 per thousand ads returned, you can do that by setting Advanced Option “ec” to 850000 micro-dollars.

For example, add the following line to the example above:

adOptions.setAdvancedOption(“ec”, “850000”);

and you will only get ads with CPM => $0.85. 

Note: The Amazon Mobile Ad Network is designed to maximize your revenue opportunity at the default setting. Setting a floor price may limit your revenue potential as it might prevent several paid campaigns from running on your placement. Amazon recommends not setting this value.

You can also specify a list of advertiser names, advertiser product categories, or URLs that aren't appropriate for your customers. Use the restrictions page under the Settings menu item in your dev portal. Please note that blocking ads may negatively impact your revenue and fill rates, and restrictions currently apply to all of your apps with ads. 

How do you see your results? That’s easy too. Check it out on the Mobile App Distribution Portal Dashboard (your dev portal home page), or by clicking on Reporting and selecting either Mobile Ads Performance to see:

• Requests
• Impressions
• Fill rates
• Click-through rates (CTR)
• Revenue per thousand impressions (RPM)
• Earnings

Or you can click on Mobile Ads Payments to see payments dispersed.

We’re happy that we’ve been able to make targeting Amazon Mobile Ads easy and straightforward. Click here to see the Mobile Ads API video and to get the Mobile App SDK. We hope you’ll give it a try in your app today.

Today, we announced the general availability of the Amazon Mobile Ads API which gives you the ability to earn great eCPM by monetizing your app with mobile ads from the Amazon Mobile Ad Network.                                                     

eCPM is the amount you earn for each 1,000 ads you display in your app. Higher values are obviously better, and we’ve seen the average eCPM for the Amazon Mobile Ad Network rise 30% since its beta launch in March.  Early adopters like Games2Win have already discovered our great monetization solution for banner ads.

‘The $2.00 eCPM we saw from Amazon far exceeded our expectation. We tested Amazon in our Kindle app first. Now we’re racing to get the Amazon ads integrated in all of our apps across all Android stores.’ says Mahesh Khambadkone, Co-Founder of Games2Win.

Starting today, the Amazon Mobile Ads API will be included as part of our Amazon Mobile App SDK. Developers who integrate the Amazon Mobile Ads API into apps they offer through Amazon may also distribute these apps using the API through any other Android platform.

To provide extra incentive to incorporate the Amazon Mobile Ads API into your apps (as if great monetization and ease of use weren’t enough), Amazon is offering a free Kindle Fire HD to developers who integrate our API in the next few weeks. All you have to do is submit your API-enabled app between July 25^th and September 1^st and send at least 500 ad requests to the Amazon Mobile Ad Network every week between September 15^th and October 19^th. (See terms and conditions below.)

We’re excited to share the success of the Amazon Mobile Ads API and encourage you to consider including the API in your next application. For more information, see the online documentation or our quick start guide.

The Amazon Mobile Ads API now includes the Auto Ad Size feature, which automatically selects the appropriate ad size to display based on the user's device and your app’s ad layout. Auto Ad Size significantly reduces integration and testing time for each app, and it provides a better user experience.

If you're working on updating your app, be sure to download the latest version of the Amazon Mobile Ads API, integrate the API into your app (technical documentation), and submit your app to Amazon and any other Android stores where your app is available. You can also view our introduction video. (This API is not included in the bundled SDK)

Steps to integrate:

1. Sign in to your Distribution Portal account. If you do not already have one, you will be prompted to create an account.
2. Submit your payment and tax information. (Skip this step if you have already submitted this information)
3. Get an Application Key by clicking on your app under My Apps or adding a new app.
4. Download and integrate the Amazon Mobile Ads API. Submit your app for approval.

Adding advertising to your apps is easy. Integrating ads doesn’t require a major redesign of your app and has minimal impact on your app’s functionality.  It is as simple as making space for the ad on the screen.  The Amazon Mobile Ads API (Beta) enables you to display high-quality ads provided from the Amazon Mobile Ad Network in a matter of minutes.  This article explains how to place ads into an existing app using the Amazon Mobile Ads API.

Set Up Your Payment Information

First and foremost, submit your payment information through the Payment Information Page and your tax information through the Tax Identity Interview. You can skip this step if you have already submitted this information through the Amazon Mobile App Distribution Portal. This is required to receive ads.

Retrieve Your Application Key

The Amazon Mobile Ads API utilizes a unique Application Key to identify and interact with an app.  Every app will have its own Application Key.  If your app is already on the Distribution Portal, you can find your Application Key on the app’s detail page.  Otherwise, create a new app and fill in the “App title” and “Category” fields.  Locate the Application Key value and set that aside.  We will use that later to register with the Amazon Mobile Ad Network.

Incorporate the Amazon Mobile Ads API Into to Your Project

Next, you will need to add the Amazon Mobile Ads API to your project.  For the purposes of this example, we will use Eclipse.

Download the Amazon Mobile Ads API (Beta) from here (this should link to our API landing page which has the file for download and the legal verbiage) and unzip it locally.

Add the JAR to Your Project

Modify the build path of your project and add the amazon-ads-<x.y.z>.jar found in the zip under the /Ads/lib folder.

• In the Eclipse project explorer, right-click on your project and open the properties
• Navigate to Java Build Path in the left pane
• Choose the “Libraries” section
• Press the “Add External JARs…” button
• Choose the amazon-ads-<x.y.z>.jar from the zip

• Choose the “Order and Export” section
• Check the box on the amazon-ads-<x.y.z>.jar

Add the amazon_ads_attr.xml to Your Project

This step is required to set up ads through the xml layout.  Copy the amazon_ads_attr.xml file from the zip located in /Ads/res/values/ into your project’s res/values/ folder.

Modify the ApplicationManifest.xml

The Amazon Mobile Apps API requires the following permissions and activities:

• Add the following permissions to your manifest

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />

• Add the following activities within the application tag

 <activity android:name="com.amazon.device.ads.MraidBrowser" android:configChanges="keyboardHidden|orientation"/>
<activity android:name="com.amazon.device.ads.VideoActionHandler" android:configChanges="keyboardHidden|orientation|screenSize"/>

Place the Ad in Your Project Layout

Now that the project is set up to use the Amazon Mobile Ads API, the next step is to add an ad to the application layout. 

• Open the layout xml you want to display your ads on from your project’s res/layout folder
• Add the following namespace to the parent layout filling in with your package name

xmlns:Amazon=http://schemas.android.com/apk/res/<my.package.name> 

• Add an AdLayout into your layout and configure the adSize attribute.  You can find the supported ad size values here
• Set the layout_width and layout_height to match the adSize.

<com.amazon.device.ads.AdLayout
        android:id="@+id/adview"
        Amazon:adSize="1024x50"
        android:layout_width="1024dp"
        android:layout_height="50dp"/>

Modify Your Activity Code

Now we can call the Amazon Mobile Ads API to load ads.

Import the Ads Classes

import com.amazon.device.ads.*;

Register with Your Application Key

Time to put that Application Key to work.  In your activities onCreate, call the AdRegistration method to register your app and then call the Amazon Mobile Ads API to load an ad.  Please note that you may only use an Application Key to display ads on the specific app for which it was issued. 

//Register App with the Ad Network
AdRegistration.setAppKey(getApplicationContext(), APP_ID); 

  //Load ad on to AdLayout
adview = (AdLayout)findViewById(R.id.adview);
adview.loadAd(new AdTargetingOptions());

Publish Your App

Submit your app to Amazon to display ads to your U.S. users and follow the attribution guidelines set forth here. The Amazon Mobile Ads API can also be used with apps that are distributed through any Android stores. Apps that use the Amazon Mobile Ads API may be distributed through any Android store as long as they are distributed through Amazon.

Congratulations!

Your app is ready to display high-quality ads from the Amazon Mobile Ad Network.  This is the simplest of configurations but the Amazon Mobile Ads API has several features for customizing your   ad layout, ad targeting, error handling, debugging, and more.  Read more about the many features of the Amazon Mobile Ads API (Beta) here.

Following the success of the In-App Purchasing API, we are pleased to introduce a new monetization option for app developers, the Amazon Mobile Ads API. Now, whether you monetize through paid apps, in-app purchases, or mobile advertising, Amazon offers a solution to help grow your business.

The Amazon Mobile Ads API is an in-app display advertising API, which offers:

• A monetization opportunity with a competitive eCPM
• High-quality ads from Amazon and brand advertisers such as Duracell Powermat and Nature's Bounty
• Easy integration and revenue tracking through the Mobile App Distribution Portal
• Distribution at scale through Amazon and other Android platforms

The Amazon Mobile Ads API serves ads to U.S. users, and works with mobile apps on Kindle Fire, Kindle Fire HD, and Android phones and tablets. Apps that use the Amazon Mobile Ads API may be distributed through any Android platform as long as they are available for download from Amazon as well.

Developers who participated in the private beta program reported an increase in ad revenue, especially on their Kindle Fire optimized apps, after integrating with the Amazon Mobile Ads API.

“We switched to Amazon from another major ad network and have seen revenue lift of 200%. Now, I call Amazon first, then another network, so my overall revenue increased 250%. The results from Amazon have greatly exceeded our expectations.”
-- James Farrier, Founder (Simple-List Free)

“Our experience with Amazon has been nothing but great. We were able to integrate in 15 minutes with the easy to follow API and documentation. We’re excited about the eCPM and fill rate so far. Our users have been happy with the quality and relevance of ads they are seeing.”
-- Steve Boymel, Co-Founder of Farlex (Dictionary)

“We decided to try Amazon's ads because our overall revenue and eCPM was low on tablets when we were using another network. We initially integrated the Amazon Mobile Ads API in one of our apps distributed through Amazon since the majority of our users there are on Kindle Fire devices. Our effort has paid off! We saw eCPM jump 300% and our revenue doubled even though fill rate was lower at the beginning. Now we have the Mobile Ads API integrated in all our free apps distributed through Amazon.”
-- Anatoly Lubarsky, Founder of x2line.com (Baby Adopter)

For more information on the Amazon Mobile Ads API, click here. We’ve also posted a short introduction video on our YouTube channel.