How to Monetize an Unreal Engine Mobile Game: Ads and IAP

How do you monetize an Unreal Engine mobile game?

You monetize an Unreal Engine mobile game with in-app purchases through the engine’s Online Subsystem, ads through a plugin (the built-in AdMob support covers little more than Android banners), and optionally a rewarded offerwall opened by a signed link. Unlike most engines, Unreal also takes a share: Epic charges a 5% royalty on each product’s lifetime gross revenue above $1 million, and that includes your ad and affiliate income.

This guide follows the Unreal Engine 5.8 documentation. Royalty and store terms were checked on October 29, 2026.

Unreal Engine royalties: what you owe Epic

The royalty addendum in the Unreal Engine EULA sets the rules:

• The rate is 5% of royalty revenue, which is worldwide gross revenue attributable to the product, “regardless of whether that revenue is received by you or any other person or entity.”
• The first $1,000,000 of lifetime gross revenue for each product is excluded, and so is any calendar quarter in which the product grosses less than $10,000.
• Gross means before the store fee. The EULA’s own example: a $10 App Store sale where Apple pays you $7 still counts as $10 of royalty revenue.
• Ads and affiliate income count. The list of royalty revenue includes revenue “from in-app advertising and affiliate programs”, next to in-app purchases, DLC and subscriptions. Offerwall earnings fall in the same bucket.
• Epic Games Store sales are excluded, along with later in-game purchases that use Epic’s payment services.
• You report quarterly. You submit a release form before you ship, then report and pay within 45 days after each quarter in which you owe royalties.

Epic’s licensing page also describes the Launch Everywhere with Epic program. For games released on or after January 1, 2025, the rate drops to 3.5% on all platforms if the game reaches the Epic Games Store before or at the same time as other stores on the same platforms. You opt in on the release form. Epic has temporarily waived the iOS part of that requirement, but an Android game would need to ship on the Epic Games Store for Android as well as Google Play to keep the lower rate.

Unreal monetization options by platform

Each store allows a different mix. Store policy facts checked on October 29, 2026.

On the Epic Games Store, Epic says developers keep 100% of the first $1 million in net revenue per title each year and 88% after that, and pay Epic nothing on in-game purchases through their own payment system. Those purchases still count toward the Unreal royalty.

In-app purchases with the Online Subsystem

Both mobile stores require their own billing for virtual items. Google’s Payments policy says apps must use Google Play’s billing system for digital goods and lists “virtual currencies, extra lives, additional playtime” among its examples. Apple’s App Review Guidelines section 3.1.1 names in-game currencies and game levels as things you must sell through in-app purchase.

Unreal wraps both stores in its Online Subsystem, so one set of Blueprint nodes or IOnlinePurchase calls works on both. Setup, per Epic’s guides:

• Android: enable Google Play support in Project Settings, enter your Google Play license key, add the com.android.vending.BILLING permission, and use OnlineSubsystemGooglePlay.
• iOS: use OnlineSubsystemIOS, turn on store purchasing in the iOS config, and use a provisioning profile whose App ID has the In-App Purchase capability.

Epic’s page Using In-App Purchases for mobile devices describes the flow in five steps: query the products, start the purchase, validate the receipt on your server, grant the item, then finalize. The Blueprint nodes are:

Finalize only after you validate and grant the item; Epic notes that skipping finalization can lead to refunds on Google Play. Restore never returns consumables, so keep the wallet on your server. The server-side wallet pattern in Build a currency system in Unity carries over to Unreal unchanged, since none of it runs in the engine.

Epic’s forums have recurring threads about purchase nodes failing on particular engine versions, so test with Google Play test accounts and Apple sandbox accounts on real devices.

Ads in Unreal Engine: built-in AdMob and plugins

Unreal’s built-in AdMob support is thin. Epic’s guide Using Ad Mob for In-Game Ads on Android covers Android only and banner ads only: you add your ad unit IDs in the Android Project Settings and call Show Ad Banner and Hide Ad Banner. It does not cover rewarded video, iOS, mediation or consent.

Google does not fill the gap. Its Google Mobile Ads C++ SDK page says the SDK was deprecated in June 2024 and reached end of maintenance on June 17, 2025, and recommends the native Android and iOS SDKs instead. So in practice you pick a plugin:

• AppLovin MAX. AppLovin publishes an official MAX Unreal plugin for Android and iOS, installed from Fab, for Unreal Engine 5.2 and later. It covers banners, interstitials and rewarded ads, and mediates other networks, including AdMob, through MAX. Rewarded ads can send a server-to-server callback to your currency server.
• Third-party AdMob plugins on Fab. Several sellers wrap the native Google SDKs. Check the last update, the supported engine versions, and iOS, rewarded and consent support before you buy.

Rewarded video is the format players accept best, interstitials belong between levels, and banners earn the least. What is ad mediation? explains how one SDK can run several networks, and Unity Ads alternatives compares the networks and mediation platforms that also serve Unreal developers. On iOS, read SKAdNetwork and ATT before you request your first ad.

Adding an offerwall to an Unreal Engine game

An offerwall lists offers from advertisers, such as playing another game or answering a survey. Players who complete one earn your soft currency, and you earn per completed offer. It reaches the same non-paying players as rewarded video. Offerwall vs rewarded video compares them.

There is no Sharklio plugin for Unreal Engine, and you do not need one. The offerwall is a web page, so the setup has three parts:

1. Your server signs an offerwall link for the signed-in player.
2. The game asks your server for that link and opens it.
3. Sharklio sends a signed server-to-server postback to your server for every credit and every reversal, and your server updates the wallet.

Step 1: sign the link on your server

The link carries the player’s ID and its HMAC-SHA256 hash, made with your link hash salt, which must never ship in your game. This Node.js route uses the code from the Offerwall link docs; requireLogin stands for your own session check:

const crypto = require("crypto");

app.get("/api/offerwall-link", requireLogin, (req, res) => {
  const userId = req.user.id;
  const hash = crypto.createHmac("sha256", linkHashSalt).update(String(userId)).digest("hex");
  const url = `https://wall.sharklio.com/${appId}?user_id=${encodeURIComponent(userId)}&hash=${hash}`;
  res.json({ url });
});

Use the account ID from your own database, not an email, so the player keeps one balance on every device.

Step 2: open it from Unreal

Fetch the link with the engine’s HTTP module and hand it to LaunchURL, which Epic’s Launch URL reference describes as opening the URL “in the platform’s web browser of choice”. Add "HTTP" and "Json" to your module’s dependencies in Build.cs:

#include "HttpModule.h"
#include "Interfaces/IHttpResponse.h"
#include "Dom/JsonObject.h"
#include "Serialization/JsonReader.h"
#include "Serialization/JsonSerializer.h"
#include "Kismet/KismetSystemLibrary.h"

void UEarnScreen::OpenOfferwall(const FString& SessionToken)
{
    TSharedRef<IHttpRequest, ESPMode::ThreadSafe> Request = FHttpModule::Get().CreateRequest();
    Request->SetURL(TEXT("https://api.yourgame.com/api/offerwall-link"));
    Request->SetVerb(TEXT("GET"));
    Request->SetHeader(TEXT("Authorization"), TEXT("Bearer ") + SessionToken);
    Request->OnProcessRequestComplete().BindLambda(
        [](FHttpRequestPtr Req, FHttpResponsePtr Response, bool bConnectedSuccessfully)
        {
            if (!bConnectedSuccessfully || !Response.IsValid() || Response->GetResponseCode() != 200)
            {
                return;
            }
            TSharedPtr<FJsonObject> Json;
            TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(Response->GetContentAsString());
            FString Url;
            if (FJsonSerializer::Deserialize(Reader, Json) && Json.IsValid() && Json->TryGetStringField(TEXT("url"), Url))
            {
                UKismetSystemLibrary::LaunchURL(Url);
            }
        });
    Request->ProcessRequest();
}

Mark the function UFUNCTION(BlueprintCallable) to wire it to an Earn button in Blueprint. To keep the player inside the game, the UMG Web Browser widget can show the same link: call its LoadURL function with the signed URL. Epic lists the widget as experimental and its forums report blank pages on some mobile engine versions, so test on real devices. Offers also open store pages, which an embedded browser has to hand off; Offerwall in a WebView covers that. The Sharklio docs say a direct link or a mobile WebView works everywhere, while an iframe only loads on the website you registered for the app.

Step 3: credit only from the postback

Never add currency in Blueprint or C++. Your postback handler checks the hash, credits each transaction_id once on status 1, and takes the reward back on status 2. Offerwall postbacks in Node.js has a complete handler, and Prevent duplicate reward credits covers retries. In the game, reload the balance from your server when the app returns to the foreground; the engine’s Application Lifecycle Component has an ApplicationHasEnteredForegroundDelegate event for this.

Store rules and Steam

Apple’s guideline 3.2.2(x) lets apps reward actions inside the app, such as watching an ad, but not force users to rate, review or download other apps to use the app. Can you put an offerwall in an iOS app? and Incentivized installs: Google Play policy go through both stores. Steam is a firm no: Valve’s Advertising on Steam page says developers should not give players “a reward for watching or engaging with advertising”, so leave the earn screen out of any Steam build. Can you put ads in a Steam game? has the full rule set.

Which monetization mix fits your Unreal game

Most free games earn more from ads and purchases aimed at different players than from either alone. Hybrid monetization for games explains how to segment payers and non-payers, and How to monetize an app compares the wider set of models. If you are still choosing an engine, How to monetize a Godot game and How to monetize a GameMaker game cover the same questions for engines with no royalty.

How to add Sharklio to an Unreal Engine game

Sharklio has no Unreal plugin, so the setup is a signed link from your server, an Earn button in your game and a postback handler.

1. Apply as a publisher at sharklio.com. Every application is reviewed by hand, and once you are approved, apps you add are live right away.
2. Add your game in the dashboard and set the currency name, icon, conversion rate, user split, rounding and wall design, with a live preview. Price it against your smallest gem pack.
3. Sign the offerwall link on your server for the signed-in player, following the Offerwall link docs, and open it with LaunchURL or a Web Browser widget as shown above. Ship the Earn button in Android and iOS builds, never in a Steam build.
4. Credit currency only on your server from the signed postback described in the Postbacks docs, once per transaction, and take it back on a reversal.
5. Test with Open as a test user and Send a test postback in Integration status, from a normal home or mobile connection, following Test your app before launch.

Frequently asked questions