Conversion Value

Definition

A conversion value is a 6-bit integer between 0 and 63 that an iOS app sets after install to describe post-install behaviour, and which the operating system reports to the ad network in an attribution postback.

Six bits is the entire budget. Everything you want to know about a user acquired from an ad — did they register, did they pay, how much — has to be encoded into one number from 0 to 63, decided within the first conversion window, and it may still be downgraded to low, medium or high before it is sent. Designing that encoding is the single highest-leverage decision in iOS measurement, and it is not reversible without losing comparability across cohorts.

The two kinds of value, and when each is sent

You set both in the same call, and the OS decides which one survives. This is why a schema must be designed as a pair: the fine value is your detailed answer and the coarse value is the answer you can still live with when the cohort is small.

import StoreKit

// SKAdNetwork 4.0
SKAdNetwork.updatePostbackConversionValue(
    12,
    coarseValue: .medium,
    lockWindow: false
) { error in
    if let error { print("CV update failed: \(error)") }
}

// AdAttributionKit, same schema, different call
try await Postback.updateConversionValue(
    fineConversionValue: 12,
    coarseConversionValue: .medium,
    lockPostback: false
)

Three encoding schemas that actually fit

The schemas below are the ones that survive contact with the constraints above. Pick one; do not blend them, because a blended range cannot be read as a single ordering.

The third option is a mixed-bit schema: split the six bits into fields, for example two bits of engagement tier and four bits of revenue bucket. It carries two dimensions at once, and it costs you the monotonic ordering that makes Apple's greater-than rule safe — so it only works if you can compute the final value in one call, at the end of the window, with lockWindow: true.

// bits 4-5: engagement tier (0-3)   bits 0-3: revenue bucket (0-15)
let value = (engagementTier << 4) | revenueBucket   // 0...63

SKAdNetwork.updatePostbackConversionValue(
    value,
    coarseValue: coarse,
    lockWindow: true       // no further updates; do this once
) { _ in }

// Decoding, server side:
// let tier   = value >> 4
// let bucket = value & 0b1111

Designing one without wasting the bits

1. Decide what decision the number has to support. If it is bid optimisation, the value must correlate with revenue; if it is creative testing, a funnel step is enough.
2. Check that the signal is observable within 48 hours of install. Anything later cannot reach the fine value at all, and belongs in the coarse value for windows 2 and 3.
3. Reserve 0 for "installed, did nothing", so that a genuine zero is distinguishable from an absent value.
4. Keep the mapping monotonic — higher always means more valuable — unless you lock the window in a single call.
5. Map every fine value onto a coarse value up front. If you cannot, the schema fails on the majority of campaigns, which sit below tier 3.
6. Version the schema and record which version each cohort used. Changing the mapping mid-flight without a version makes two cohorts numerically comparable and semantically different.
7. Publish the mapping to every ad network before launch. They optimise on the number; if their interpretation differs from yours, their bidding is optimising for something else.

Both frameworks read the same schema, so this work is not SKAN-specific: the encoding you design here is what AdAttributionKit sends too.