Skip to main content

Referral and Install Fraud for Small Apps: The Cheap Attacks and the Rules That Stop Them

An app that pays a reward for each invited friend, or pays a partner for each install, has put a price on a new install. Anyone who can make an install look new, and look as if it came through the right link, can collect that price. The attacks need little skill: a spare phone, an emulator or an edited URL is enough.

This article lists the cheap attacks, the server-side rule that catches each one, and what each rule can wrongly flag. It then covers when to block and how to pay rewards.

Why a small app gets attacked at all

A referral reward gives credit, a free month or cash to a user when someone they invited signs up. A paid install pays a creator, an affiliate or a partner for each install credited to their link.

Both pay on an event the payer never sees: an install on someone else's phone, reported by the app itself. Deciding which link an install came from is called attribution, and the payout follows it. The reward is worth the same to an attacker whatever the app's size.

The cheap attacks

  • Inviting yourself. A user taps their own referral link, installs, and signs in to the account they already have.
  • A second account on one device. The same user installs through their own link and signs up again under another email address, on the same phone.
  • Emulators. A virtual phone on a computer can be wiped so that it holds the same data as a new device, then used for another install.
  • Click injection and click flooding. Click injection fires a tap after a download has already begun, to claim an install the tap did not cause. Click flooding sends taps in bulk with no person behind them, hoping real installs get matched to them later.
  • Tampered or repackaged builds. A modified copy of your app, signed with someone else's key, reports whatever its author wants. Another trick replays one real install's signal on other devices.
  • VPNs and data centres. These hide where installs come from, so one person's work looks like many people on many networks.

The rule that catches each, and what it can get wrong

The rules below are the ones in AdTo's fraud rules reference. Each is a plain comparison, so every flag can be explained. The docs grade the install rules: strong ones have no honest explanation and moderate ones trip on busy shared networks. Three weak ones (stale_referrer, stale_clipboard, stale_meta) mostly mean an old link and are left out of the table.

AttackRuleFires whenWhat it can wrongly flag
Inviting yourselfNo flag: no referral is recordedA user who identifies with the referrer's own id records no referral. Neither does a reinstall, or an existing customer who identifies on the new install.No flag. But a returning user who reinstalls through a friend's link earns the friend no referral.
Second account on one devicereferral_same_device (strong)The referred customer signed up on a device the referrer used: the referrer identified on it, had a session on it, or installed the app on it first.None documented. It compares devices, not people: a friend who signs up on a fresh install the referrer has already signed in on is flagged.
The referrer's other devicesreferral_same_network (weak)The referred install came from a network one of the referrer's other devices used in the 30 days before. Never on cellular data.A household.
Emulatorsemulator (strong)The SDK reports a simulator or emulator, the device model names one, or an Android phone reports an x86 CPU.Your own simulator builds while you test.
Click injectionclick_injection (Android) and impossible_speed (both strong)The matched tap came more than 5 seconds after Google Play began the download, or less than 10 seconds before the first launch.None documented. click_injection is not checked without a Google Play install-begin time, as on iOS.
Click floodingclick_storm_ip (moderate)The matched tap's network sent more than 100 taps in the hour before it.An office, a university, a hotel.
Many installs from one placeinstall_velocity_ip (moderate)At least 5 other installs (25 on cellular data) came from the same network in the 24 hours before.The same shared networks.
Tampered or repackaged buildssigning_cert_mismatch and installer_mismatch (both strong, Android)The app is signed with a certificate that is none of the SHA-256 fingerprints you listed for it. Or a Google Play install referrer (the referral data the store hands the installed app) names a tap, but something other than Google Play installed the app.Every store install, if you listed only your upload key. Internal-sharing and debug builds signed with an unlisted key.
Replayed install signalclick_reuse (strong)A store referrer or pasted link names a tap that another device's install already holds.None documented. The signal never earns credit, so there is nothing to block.

Under Play App Signing, Google signs the builds delivered to users with the app signing key, so that key's fingerprint must be in your list. installer_mismatch is never flagged when the installer is unknown, or for Play Instant.

The timing rules trust only server clocks. Google Play's Install Referrer API returns server-side timestamps for the referrer click and for the start of the install. The device clock is never used.

No rule in AdTo's documented list names a VPN or a data centre. referral_same_device does not look at the network at all, and the two volume rules still count a crowd behind one network. Do not rely on the network rules alone: they compare one network at a time.

Flag or block: when to refuse credit and when only to mark

By default every hit is a flag. Attribution stands, and the flag travels with the install so your own code can decide. A rule acts only after you tick it for an app, on the dashboard's Apps page under Fraud rules.

Blocking does not delete the install: its record keeps the match as evidence. For the install rules above it withholds credit: the install counts as organic (credited to no link), with no routing, and the tap stays used so no other install can take it. For a referral rule it rejects the referral, which is stored as rejected, sends no referral.converted and is not counted. A wrong block costs a real user the screen their link pointed to, and costs the link its credit.

  1. Start with flags only. On the Installs page, each install's detail lists every rule with what it compared: flagged, clear, or not checked and why.
  2. Block strong rules once your setup is clean. The exception is signing_cert_mismatch: block it only after real store installs come through clear.
  3. Keep moderate rules as flags. An office or a campus trips them, and those are real users.
  4. Reject on referral_same_device if rewards cost you money. Leave referral_same_network as a flag, because a household trips it.

Paying rewards safely: decide on the server

Never grant a reward from the app. A modified app can claim anything. The record that counts is made on the server, from the link the install was credited to. A referral link's customer is fixed on the server. A referrer passed as a URL parameter (adto_referrer) is whatever the URL says, so anyone can edit it. Use per-user referral links where money is involved.

When a referred user signs up, your backend receives a referral.converted webhook, a signed POST from AdTo. In order:

  1. Verify x-adto-signature, an HMAC-SHA256 of the raw request body, before parsing anything.
  2. Deduplicate on event_id, which is the same on every retry, and key the reward on referral.id.
  3. Read referral.fraud_flags. It holds the install's flags and the referral rules that hit.
  4. Apply your policy, then pay.
const STRONG = new Set([
  "referral_same_device", "emulator", "impossible_speed",
  "click_injection", "installer_mismatch", "signing_cert_mismatch",
  "click_reuse",
]);

function decideReward(referral) {
  const flags = referral.fraud_flags;
  if (flags.some((f) => STRONG.has(f))) return "deny";
  if (flags.length > 0) return "review"; // e.g. referral_same_network
  // Stricter: also review when match_confidence is not "guaranteed".
  return "grant"; // one reward per referral.id
}

Two habits make these attacks less profitable: pay after the new user has done something of value, such as a first purchase, and cap what one referrer can earn.

Paid installs work the same way from app.installed. The payload carries matched, the link's slug, is_reinstall, fraud_flags and blocked_by, so your server can count payable installs per link and leave out reinstalls and flagged ones. A verdict can be upgraded later by app.install_updated, so settle with partners on a schedule, not per event.

What a small team should not try to build

  • Checks that run in the app and report their own result. Apple's documentation warns against letting an app run security checks on itself, because a compromised copy can fake the outcome.
  • Your own device attestation. The platforms provide it. Google's Play Integrity API helps your backend check that a request comes from your genuine app, installed by Google Play, on a genuine and certified Android device. With Apple's App Attest, Apple's servers certify that a key belongs to a valid instance of your app. Google advises using its API with other signals and not alone, and Apple notes that not all devices can use App Attest.
  • A VPN or data-centre address list. Blocking on it turns away real people who use a VPN.
  • A scoring model. A score is hard to explain to a user whose reward was declined. A named rule is not.

These rules catch abuse through the real SDK. The SDK key ships inside the app, so someone who extracts it can send requests that look like the SDK's, with any values. The rules do not prove that a request came from a genuine device, and device attestation is not part of AdTo yet.

Doing this with AdTo

AdTo checks every install against a fixed set of explainable rules. Flags ride on the install verdict, the install webhooks, exports and the dashboard. Blocking is set per app and per rule, and nothing acts until you tick it.

For referrals, createReferralLink in the flutter_adto SDK gives each user one link at https://<username>.adto.app/<slug>. The first identify of a new customer on a fresh install credited to that link records the referral, and referral.converted delivers it to your backend with its flags.

AdTo is a hosted service, not a measurement partner (MMP): it has no SKAdNetwork support and sends no postbacks to ad networks. Plans are by monthly active users, every plan has every feature, and the free plan covers apps under 5,000 monthly active users.

Create an AdTo account, then follow the referral programs guide.